■MELSOFT Gemini 体験版動画テキスト
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/trial.html

=================================================================================

インストール方法と基本操作説明

インストール方法とMELSOFT Gemini起動後の各種メニューやマウス操作などの基本操作を説明します。
https://youtu.be/qP0olfUXmNc

Geminiのインストールについて説明します。
GeminiSetupをダブルクリックします。
他のすべてのアプリケーションを終了して[次へ]をクリックします。
ライセンス許諾書が表示されますので、内容を確認してから「同意する」をクリックします。
Geminiのインストール先を指定し、インストールをクリックします。
ショートカットの作成とファイルの関連付けの内容を確認して、チェックを入れて[次へ]をクリックします。
インストールが完了しましたので、完了をクリックします。
インストールについての説明は以上となります。
Geminiのライセンス認証について説明します。
Geminiのアイコンをダブルクリックします。
Geminiのアクティベーションガイドが表示されますので、[次へ]をクリックします。
ライセンスを選択します。
ライセンスにはスタンドアロンライセンスとネットワークライセンスの2種類があります。
スタンドアローンライセンスを選択し、[次へ]をクリックします。
製品キーを入力し、[次へ]をクリックします。
ライセンスの設定が完了しましたら[完了]をクリックします。
Geminiが起動します。
ライセンス認証についての説明は以上となります。
Geminiのユーザーインターフェースについて説明します。
Geminiのユーザーインターフェースはいくつかの要素で構成されています。
メニュータブを選択すると、ツールやコマンンドを使用することができます。
eカタログにはモデルの部品となるコンポーネントが入っています。
タイプ別モデルを展開します。
[Layouts]のツリーを展開し、[Layouts]をクリックします。
コレクションのところにマウスカーソルを合わせスクロールします。
「Machine Tending」を3Dワールド上にドラッグアンドドロップします。
eカタログからコンポーネントを配置することができます。
セルグラフは現在の3Dワールドのレイアウトを一覧として表示しています。
[出力]ウィンドウは処理中の経過メッセージや処理結果を表示します。
[プロパティ]ウィンドウでは、選択したコンポーネントのプロパティを編集することができます。
3Dワールド上部にあるシミュレーションコントロールバーは、シミュレーションの開始停止、リセット速度調整アニメーションのエクスポートをすることができます。
3Dワールド左下にあるビューセレクターと左上にある不動原点は3Dワールドでの視点を切り替えます。
3Dワールドツールバーは、コンポーネントの表示方法を変更することができます。
3Dワールドのリセット方法を説明します。
最初にファイルタブを選択します。
次に全て消去を選択します。
3Dワールドに表示されていたものが全て消去されました。
Geminiのユーザーインターフェースについての説明は以上となります。
ヘルプの使用方法について説明します。
ヘルプタブを選択します。
ヘルプアイコンを選択すると、ヘルプファイルが表示されます。
ヘルプファイルには目次から探す方法とキーワードを検索する方法があります。
目次は階層を展開し、五階層をクリックします。
検索はキーワードを入力し、検索結果一覧からダブルクリックします。
ヘルプの使用方法についての説明は以上となります。
eカタログについて説明します。
[ホーム]タブに戻ります。
eカタログにはタイプ別モデルと製造者別モデルの二つの分類があります。
タイプ別モデルはコンポーネントの種類別に分類され、種類別の中で製造者別に分類されています。
製造者別モデルは製造者別に分類され、製造者別の中で種類別に分類されています。
eカタログについての説明は以上となります。
3Dワールドツールバーについて説明します。
3Dワールドに複数のコンポーネントが配置されているとき、3Dワールドツールバーの一番上すべてのアイコンを選択すると、すべてのコンポーネントを表示します。
選択を拡大アイコンを選択すると選択しているコンポーネントが画面内に収まるように縮尺表示します。
ヘッドライトアイコンを選択すると、視点の方向からライトを点灯し、正射アイコンを選択すると、正投影表示に切り替えることができます。
レンダリングモードアイコンを選択すると、コンポーネントの表示方法のリストが表示され、その中から表示方法を選択します。
フレームタイプアイコンを選択すると、3Dワールド上のフレームのリストが表示され、表示非表示を切り替えることができます。
ポジションフレームディスプレイオプションアイコンを選択すると、フレームの軸とラベルの表示非表示を切り替えることができます。
Viewエディタアイコンを選択すると、現在の支点の位置を保存することができます。
3Dワールドツールバーについての説明は以上となります。
3Dワールドの視点変更について説明します。
最初にマウス操作での視点変更について説明します。
右クリックをしながらマウスをドラッグすると視点を回転させることができます。
右ボタンと左ボタンを同時にクリックしながらドラッグすると、視点を平行移動させることができます。
同様にマウスのホイールをクリックしながらドラッグすることでも視点を平行移動させることができます。
マウスのホイールを回転させると視点を拡大縮小します。
3Dワールド上のコンポーネントにカーソルを合わせ、右クリックすることでメニューを開きます。
メニューから3Dビューの中心を選択すると、選択したコンポーネントを視点の中心にすることができます。
次にビューセレクターでの視点変更について説明します。
ビューセレクターのDRFLBアイコンを左クリックすると、指定した方向角度からの視点に変更することができます。
Dアイコンをクリックすると、3Dワールド情報からの視点となり。
ダブルクリックすると3Dワールド下方からの視点となります。
Viewセレクタアイコンの間や淵をクリックすることで視点を変更することもできます。
3Dワールドの視点変更についての説明は以上となります。
コンポーネントの選択、移動方法について説明します。
最初にコンポーネントの選択方法について説明します。
選択アイコンをクリックします。
コンポーネントを選択すると、選択されたコンポーネントがハイライトされます。
クリックしながらドラッグすると範囲選択することができます。
範囲にかかっているすべてのコンポーネントを選択します。
コントロールキーを押しながらコンポーネントを選択すると複数選択することができます。
コンポーネントの選択についての説明は以上となります。
コンポーネントの移動について説明します。
移動アイコンをクリックします。
コンポーネントをクリックすると矢印や面が表示されます。
矢印や面をドラッグすることでコンポーネントを移動させることができます。
赤い矢印をドラッグすると、コンポーネントX軸方向に移動させることができます。
緑の矢印をドラッグするとY軸方向に移動させることができます。
青い矢印をドラッグすると、Z軸方向に移動させることができます。
赤い面をドラッグすると、コンポーネントのX軸を固定した状態で移動することができます。
緑の面をドラッグすると、Y軸を固定した状態で移動することができます。
青い面をドラッグすると、Z軸を固定した状態で移動することができます。
曲線をドラッグすると、コンポーネントの角度を変更することができます。
赤い曲線はX軸を中心に角度が変更でき、緑の曲線はy軸を中心に青い曲線はZ軸を中心に角度を変更することができます。
ピンク色の丸をドラッグすると、コンポーネントを自由に移動させることができます。
コンポーネントの選択移動についての説明は以上となります。
シミュレーションコントロールバーについて説明します。
コントロールバーにある再生ボタンをクリックするとシミュレーションを開始します。
右側にあるプラスとマイナスの間にあるシークバーで、シミュレーションの速度を調整します。
シミュレーション再生中は再生ボタンが一時停止ボタンに変わり、ボタンをクリックするとシミュレーションを一時停止することができます。
再生ボタンの左にあるリセットボタンをクリックすると、3Dワールドの状態をリセットすることができます。
シミュレーションコントロールバーについての説明は以上となります。
これでGeminiの基本操作説明を終わります。
ご視聴ありがとうございました。

=================================================================================

はじめてのラインシミュレーション

人とコンベアと加工機のラインを例に、ライブラリ部品(eカタログ)を用いてラインを設計し、シミュレーションする方法を説明します。
https://youtu.be/PBtcgAz3HNI
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/img/data_bhpf01120021.zip

本動画では、人とコンベアと加工機のラインを例に、MELSOFT Geminiを用いてラインを設計し、シミュレーションする方法について説明します。
はじめに、マウス操作について説明します。
マウスホイールをスクロールすると、視点を拡大/縮小することができます。
ホイールクリックした状態でマウスをドラッグすると、視点を平行移動することができます。
右クリックした状態でマウスをドラッグすると、視点の角度を変えることができます。
マウス操作の説明は、以上になります。
次に、eカタログを使用し、ラインレイアウトを構築します。
左ウィンドウの[eカタログ]-[タイプ別モデル]-[Machines]-[Visual Components]をクリックします。
部品の配置方法には、eカタログ上の部品をダブルクリックする方法と、任意の場所へドラッグ＆ドロップする方法の2種類があります。
ダブルクリックした場合は、3D空間の原点に、ドラッグ＆ドロップした場合は、ドロップした場所にそれぞれ配置されます。
eカタログの中のParametric Latheを選択し、ドラッグ&ドロップして3D空間に配置します。
[タイプ別モデル]-[PM Flow Components]をクリックします。
eカタログの中のFeederを選択し、ドラッグ&ドロップして3D空間に配置します。
Feederは、シミュレーションを実行すると製品を生成して、Feederに接続されているコンベアなどに製品を流す部品です。
eカタログの中の「From Conveyor Process」を選択し、ドラッグ&ドロップして3D空間に配置します。
「From Conveyor Process」はコンベアから流れてきた製品を別の部品へ輸送したい時に、コンベアに接続して使用します。
To Conveyor Processを3D空間上へドラッグ&ドロップします。
To Conveyor Processはコンベアへ製品を輸送したい時に、コンベアに接続して使用します。
[タイプ別モデル]-[Conveyors]-[Visual Components]をクリックします。
「Conveyor」を3D空間上へドラッグ&ドロップします。
装置間を輸送する人、人の制御部品、移動範囲を設定します。
[タイプ別モデル]-[PM Resources]をクリックします。
eカタログの中のHumanを選択し、ドラッグ&ドロップして3D空間に配置します。
[タイプ別モデル]-[PM Transport Controller]をクリックします。
eカタログの中の「Human Transport Controller」を選択し、ドラッグ&ドロップして3D空間に配置します。
「Human Transport Controller」は、Humanと接続して、製品の輸送や作業を制御します。
[タイプ別モデル]-[PM Resource Utilities]をクリックします。
eカタログの中のPathway Areaを選択し、ドラッグ&ドロップして3D空間に配置します。
Pathway Areaは、Human Transport ControllerなどのTransport Controllerと接続することで、人などのリソースが移動できる範囲を指定します。
部品のサイズを変更する方法には、プロパティの数値を変更する方法と、部品をドラッグして変更する方法があります。
今回は、部品をドラッグする方法でサイズを変更します。
[ホーム]タブ-[マニピュレーション]-[インタラクティブ]をクリックします。
インタラクティブは、部品の長さを変更することができます。
また、部品の可動部を動作させることもできます。
Pathway Areaの濃いグレー部分にカーソルを持っていくと、矢印から指マークに変わります。
その状態でドラックしてサイズを変更します。
部品は、コピー&ペーストで複製することができます。
コンベアを選択した状態で、右クリックをして"コピー"を選択します。
任意の位置で再度右クリックし、"貼り付け"を選択するとConveyorが複製されます。
Ctrl+CとCtrl+Vのショートカットキーでも複製することができます。
複製したConveyor #2を移動するため、[ホーム]タブ-[マニピュレーション]-[PnP]をクリックします。
部品の移動は、[マニピュレーション]-[移動]をクリックしても行えます。
Conveyor #2が選択された状態で、ドラッグ&ドロップすると任意の場所に配置することができます。
PnP接続で部品同士を相互に接続します。
PnPで接続した部品同士は自動的に製品が流れるようになります。
部品をクリックしたときに、黄色の三角マークが表示されている場合はPnPで接続することが可能です。
また、部品をある程度近づけると自動で接続されます。
PnPを選択した状態でFeederを選択し、ドラッグして「Conveyor」に近づけると緑色の矢印が表示されます。
矢印が表示されない場合は、黄色の三角マークの向きがあっていない可能性があります。
接続が成功した場合、黄色の三角マークが緑色になります。
続けて、「FromConveyor Process」と「To Conveyor Process」をコンベアとPnPで接続します。
「From Conveyor Process」をドラッグして「Conveyor」に近づけ、接続します。
「To Conveyor Process」をドラッグしてConveyor #2に近づけ、接続します。
PnPの説明は以上になります。
Human、Human Transport Controller、Pathway Areaのインターフェース接続をします。
インターフェース接続をすることで人に作業や輸送タスクを割り当てたり、移動範囲を指定できるようになります。
[接続]-[インターフェース]をクリックして、インターフェース接続を行います。
「Human Transport Controller」を選択するとResources、Pathways、Idle/ChargingLocations、Toolsの4つのインターフェースが表示されます。
今回は、ResourcesとPathwaysの接続をします。
インターフェース名をクリックすると、そのインターフェースと接続できる部品のインターフェースが表示されます。
Resourcesをクリックすると、HumanのPMResourceが表示されます。
Resources横の丸をドラッグして、PMResource横の丸、またはHuman上までドラッグしドロップするとインターフェースが接続されます。
Human Transport ControllerのPathwaysをクリックするとPathwayAreaが表示されるため、同様の手順でインターフェースを接続します。
この2つのインターフェース接続で、Human Transport Controllerが操作するリソースと、そのリソースの移動範囲が設定できました。
インターフェース接続の説明は以上になります。
ライン上の部品や製品の流れ(プロセスフロー)を設定します。
今回は、Conveyor上の製品をParametric Latheへ輸送し、加工された製品をConveyor #2へ輸送するプロセスフローを作成します。
[プロセス]タブ-[エディタ]-[フロー]をクリックすると、部品上に青色の点やひし形のアイコンが表示されます。
ひし形アイコンをクリックするとコントローラーの選択/非選択を切り替えます。
「Human Transport Controller」をクリックして選択状態にします。
コントローラーを選択状態にしプロセスフローを設定すると、製品の輸送にコントローラーを割り当てることができます。
青色の点はプロセスを表しており、カーソルを合わせるとプロセス名が表示されます。
プロセスとは、部品上に流れてきた製品に対して、加工などの処理を行う場所です。
プロセス名を右クリックすると、そのプロセスの動作内容が確認できます。
プロセス名をクリックすると点の色が青から黄に変化します。
この状態で別のプロセス名をクリックすると、プロセスフローが作成されます。
「Human Transport Controller」を選択した状態で、FromConveyor-Parametric Lathe-ToConveyorと順にクリックします。
プロセスフローの設定の説明は以上になります。
シミュレーションを再生します。
シミュレーションの再生速度は、再生ボタン右の"シミュレーション速度係数"や"速度"で変更できます。
Conveyorから流れてきた製品をHumanがParametric Latheへ輸送し、加工が終わった製品をHumanがConveyor #2まで輸送します。
ConveyorとFrom Conveyor Process の位置によっては、Humanが製品をピックする際にConveyorを突っ切って移動します。
その場合は、製品のピック位置を変更することで改善できます。
ピック位置を変更するためには、[ResourceApproach]や[ResourceOffset]プロパティを変更します。
[ResourceApproach]は、製品をピックする際の体の向きを設定します。
画面では、"Right"から"Left"に変更したことで、Humanの体の向きが変わりました。
[ResourceApproach]は、製品をピックする際の体の向きを設定します。
画面では、Xを500に変更したため、Humanが製品をピックする位置が移動しました。
以上で、MELSOFT Geminiを用いたラインのシミュレーション方法についての説明を終わります。

=================================================================================

はじめての装置シミュレーション

XYテーブルを例に、CADデータをインポートして機構・動作を設定し、制御プログラムと接続してシミュレーションする方法を説明します。
https://youtu.be/XX6ttGJoAlk
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/img/data_bhpf01120022.zip

本動画では、XYテーブルを例に、MELSOFT Geminiを用いて、インポートしたCADデータと制御プログラムとを連携してシミュレーションする方法について説明します。
今回のデモでは、XYテーブルをシンプルモーションユニットで制御しており、各軸の実現在値をGemini上のXYテーブルと同期することで動作させます。
今回使用する3Dモデルには、可動する部分が4つあります。
①はX軸方向に、②はY軸方向に可動し、どちらもシンプルモーションユニットが制御します。
③はZ軸方向に可動し、ON/OFF信号で制御します。
④は②の動きに連動し、円の中心を軸に回転します。
はじめに3Dモデルのインポートについて説明します。
[ジオメトリ]をクリックすると、ファイル選択画面が表示されます。
使用したい3DCADファイルを選択し、[開く]をクリックします。
[モデルをインポート]ウィンドウが表示されます。
使用している3DCADとGeminiで座標系が異なる場合、[上軸]を変更します。
今回のデモ用モデルでは[上軸]を[-X]に設定します。
[インポート]をクリックし、3DCADデータを読み込みます。
3Dモデルのインポートについての説明は以上となります。
次に可動部品を抽出して機構設定する方法について説明します。
X、Y、Zの各軸毎に設定していきます。
まずX軸方向に可動する部品に対して機構設定を行います。
[モデリング]タブを選択し、X軸方向に可動する部品をCtrlキーを押しながら選択していきます。
可動部品を選択し終えたら、右クリックから[抽出]-[抽出リンク]を選択します。
[コンポーネントグラフ]に「Link_1」が追加されます。
「Link_1」を選択した状態で[リンクプロパティ]の[JointType]を「直進」に設定します。
回転運動の場合は"回転"、直線運動の場合は「直進」、別部品の運動量と連動して回転・直線運動する場合は"回転/直進フォロワー"を指定します。
[JointType]を設定したら動作する方向を[軸]で指定します。
「Link_1」の動作方向は+Xであるため、「+X」に設定します。
選択しているリンクにおけるXYZ軸と"+方向"、"-方向"は、赤枠内の矢印で確認できます。
赤色がX軸、緑色がY軸、青色がZ軸を示し、矢印の方向が+方向になります。
[Controller]には「新規サーボコントローラ」を選択し、[コンポーネントグラフ]の[ビヘイビア]に「サーボコントローラ」が追加されたことを確認します。
動作範囲を測定し、可動範囲を設定します。
[モデリング]タブの[ツール]-[測定]を選択します。
X軸方向に動かす始点と終点を選択して距離を測定し、可動範囲の最大が900mmであることを確認します。
[最小リミット]に「0」、[最大リミット]に測定した値の「900」を入力します。
設定ができたら、可動部品を動かしてみます。
[インタラクティブ]を選択し、「Link_1」をX軸方向にドラッグすることで直線運動することを確認します。
可動範囲を超えて動作させた場合、[リンクプロパティ]の"J1"にビックリマークが表示されます。
[プログラム]タブの[リミット]-[リミットで停止]にチェックを入れることで、可動範囲を超えた動作を制限できます。
次にY軸方向に可動する部品に対しても機構設定を行います。
X軸と同様に、Y軸方向に可動する部品を選択し、[抽出リンク]をクリックします。
[コンポーネントグラフ]に「Link_2」が追加されます。
「Link_2」を選択した状態で[リンクプロパティ]の[JointType]を「直進」に設定し、[軸]を「+Y」に設定します。
[Controller]には「新規サーボコントローラ」を選択し、[コンポーネントグラフ]に「サーボコントローラ_2」が追加されたことを確認します。
動作範囲は「Link_1」と同じであるため、[最小リミット]に「0」、[最大リミット]に「900」を入力します。
設定ができたら、可動部品を動かしてみます。
[インタラクティブ]を選択し、「Link_2」をY軸方向にドラッグすることで直線運動することを確認します。
ここまでは先ほどと同じ設定となりますが、この状態では「Link_1」をドラッグして動作させても、「Link_2」が追従して動作しません。
追従させるためには、[コンポーネントグラフ]の「Link_1」の中に「Link_2」をドラッグ&ドロップします。
次にZ軸方向に可動する部品に対しても機構設定を行います。
X軸、Y軸と同様に、Z軸方向に可動する部品を選択し、[抽出リンク]をクリックします。
[コンポーネントグラフ]に、「Link_3」が追加されます。
「Link_3」を選択した状態で[リンクプロパティ]の[JointType]を「直進」に設定し、[軸]を「-Z」に設定します。
[Controller]には「新規サーボコントローラ」を選択し、[コンポーネントグラフ]に「サーボコントローラ_3」が追加されたことを確認します。
動作範囲は100mmであるため、[最小リミット]に「0」、[最大リミット]に「100」を入力します。
「Link_3」も同様に[コンポーネントグラフ]の「Link_2」の中に「Link_3」をドラッグ&ドロップします。
最後に回転動作するオレンジの部品に対しても機構設定を行っていきます。
[移動]をクリックします。
これまでと同様にリンク設定した場合、XYテーブルの原点を中心に回転動作するため、回転動作の中心を変更します。
「Link_2」を選択し、[モデリング]タブの[リンクをクリエイト]を選択します。
[コンポーネントグラフ]の「Link_2」の子階層に「Link_4」が生成されます。
「Link_4」を選択した状態で、[モデリング]タブの[スナップ]を選択し、回転動作する部品の中心としたい位置でクリックします。
[リンクプロパティ]の"Offset"にオフセット値が入っていることを確認します。
Y軸の動作にリンクした動作にしたいので、[JointType]を"回転フォロワー"に設定し、[軸]を「-Z」に設定します。
"ドライバー"をY軸方向の可動部である「Link_2」で指定している"J2"に設定します。
「Link_4」に部品を紐づけるため、[コンポーネントグラフ]下段で部品を選択し、Shiftキーを押しながら「Link_4」にドラッグ&ドロップします。
[インタラクティブ]で動作させると、Y軸の動作にリンクして回転動作することが確認できます。
可動部の抽出から機構設定に関しての説明は以上となります。
次に機構設定を行った可動部に対して動作設定を行います。
[モデリング]タブが選択された状態で、「Link_1」を選択します。
今回のデモにおいてシンプルモーションから送られてくる現在値は0.1μm(マイクロメートル)単位です。
Geminiの設定はmm(ミリメートル)なため、単位換算を行います。
[リンクプロパティ]の"数値式"の"VALUE"にシンプルモーションの値が入ります。
ここの値を"VALUE/10000(1万)"することで、単位をmmに換算して動作させることができます。
[最小リミット]、[最大リミット]はシンプルモーションの値の範囲を設定するため、最小リミット0、最大リミット9000000に設定します。
これで「Link_1」の動作設定が終わりましたので「Link_2」も同様に設定します。
「Link_3」はシーケンサ側からのON/OFFの信号を受け取って動作するため、信号を受け取るシグナルを追加します。
まずは、戻り側から出側への移動を指示する「Y101」用のシグナルを作成します。
[コンポーネントグラフ]の「Demo_XYZTable」を選択した状態で、[ビヘイビア]から、[シグナル]の[ブール型]を追加します。
[コンポーネントグラフ]の[ビヘイビア]に「BooleanSignal」が追加されます。
他のビヘイビアと識別しやすくするために、[プロパティ]から"名前"を"Y101"と対応するシーケンサ側のデバイス名と一致するように変更します。
次に、出側から戻り側への移動を指示する「Y102」用のシグナルを作成します。
同様の手順で「Demo_XYZTable」の[ビヘイビア]に[シグナル]の[ブール型]を追加し、[名前]を"Y102"に変更します。
今度はGeminiから「Link_3」の現在地をシーケンサ側に送信するためのプロパティを追加します。
まずは、出側であることを示す「X101」用のプロパティを追加します。
[コンポーネントグラフ]の「Demo_XYZTable」を選択した状態で、[プロパティ]から、[ブール型]を選択します。
[コンポーネントグラフ]の[プロパティ]に「Boolean_1」が追加されます。
シグナルと同様に他のプロパティと識別しやすくするために[名前]を"X101"に変更します。
次に戻り側であることを示す「X102」用のプロパティを追加します。
同様の手順で「Demo_XYZTable」の[プロパティ]に[ブール型]を追加し、[名前]を"X102"に変更します。
最後にシーケンサ側からのON/OFFの信号に応じて実際に「Link_3」を動作させる設定を行います。
この設定にはパイソンスクリプトを用います。
「Link_3」を選択した状態で、[ビヘイビア]から、[その他]の[パイソンスクリプト]を選択します。
プログラムの作成画面が表示されます。
ここでは完成したプログラムを貼り付けて、プログラムの説明を行います。
配付したテキストファイルからプログラムをコピーして、作成画面でctrl+A-ctrl+Vの操作をして、プログラムを貼り付けてください。
ここで変数を定義しています。
動作は「while True]の中にif文で記述し、処理を繰り返すようにしています。
まず、出側への移動を指示するY101がTrueの場合、戻り側にあったことを示すX102をFalseにします。
「Link_3」を制御するサーボコントローラへ100の位置まで前進する指令moveJoint(0,100)を実行し、出側にあることを示す"X101"を"True"にします。
次に戻り側への移動を指示する"Y102"が"True"の場合、出側にあったことを示す"X101"を"False"にします。
「Link_3」を0の位置まで後退させ、戻り側にあることを示す"X102"を"True"にします。
記述が終わったらコンパイルをクリックし、プログラムの作成画面を閉じます。
動作設定に関しては以上となります。
次にセンサーの設定を行います。
[モデリング]タブを選択し、センサーのモデルを選択します。
右クリックから、[抽出]-[コンポーネントを抽出]を選択し、センサーコンポーネントを抽出します。
センサーを使用するためには、検知位置を指定するフレーム、センサー本体、センサーのON/OFF信号を格納するブール型シグナルを追加する必要があります。
抽出したコンポーネントを選択した状態で、[フィーチャ]を選択し、[フレーム]を選択します。
センサーコンポーネントの原点に「フレーム」が生成されるので、センサーの検知位置までドラッグで移動します。
[ビヘイビア]を選択し、[センサー]から[レイキャスト]をクリックすると[コンポーネントグラフ]に「RaycastSensor」が追加されます。
同様に[ビヘイビア]を選択し、[シグナル]から[ブール型]をクリックすると[コンポーネントグラフ]に「BooleanSignal」が追加されますので、"プロパティ"から[名前]を"X100"に変更します。
[コンポーネントグラフ]の「RaycastSensor」を選択し、[プロパティ]から"最大範囲"や"検出しきい値"を設定します。
"ブールシグナル"には"X100"を設定し、"フレーム"には、先ほど追加した"フレーム"を設定します。
センサーの設定は以上となります。
ここからはGeminiとGX Simulator3を接続する方法を説明します。
まずは、GX Simulator3を起動します。
GX Works3のファイルを開き、[デバック]-[シミュレーション]-[システムシミュレーション]-[起動]の順に選択します。
[システム追加]を選択し、プロジェクト名を確認後、[OK]を選択します。
[シンプルモーションRD77MS2]にチェックを入れ、[開始]を選択します。
起動したGX Simulator3にプログラムを書込みます。
GX Works3の画面から、[デバック]-[シミュレーション]-[システムシミュレーション]-[接続先設定]の順に選択すると、[シミュレーション接続先設定]画面が表示されます。
"R16CPU"が選択されていることを確認し、[接続]を選択します。
[オンライン]タブから[シーケンサへの書込み]を選択すると、[オンラインデータ操作画面]が表示されます。
"パラメータ+プログラム"を選択し、"シンプルモーション"にチェックを入れ、[実行]を選択します。
途中、確認メッセージが表示されるので、[OK]を選択します。
書込みが完了したら、[OK]をクリックし、[オンラインデータ操作]画面を閉じます。
[System:1画面]に戻り、[RESET]をクリックします。
"RDY"が点灯したら、[RUN]を選択します。
次にGemini側でGX Simulator3との通信設定を行います。
[接続性]タブを選択します。
[接続性コンフィグ]の「MITSUBISHI ELECTRIC FA」を選択し、右クリックから[サーバを接続]を選択します。
接続を編集する画面が表示されるので、"PC側I/F"を"GX Simulator3"、"CPUタイプ"を"R16"に設定します。
"先頭デバイス・デバイス点数"でGeminiと通信するデバイスの種別および範囲を設定します。
今回は、「Link_3」を制御するXデバイス3点、Yデバイス3点、「Link_1」の現在値座標1点、「Link_2」の現在値座標1点を設定します。
まず「X100」から3点分、「Y100」から3点分、「D1000」から1点分、「D2000」から1点分確保します。
「D1000」と「D2000」は、"データ型"を"DWORD"に設定します。
設定が終わったら、[接続をテスト]を選択し、正常に接続できるかを確認します。
接続が確認出来たら、適用を選択します。
[接続性コンフィグのサーバ]右横のアイコンをクリックすると、GeminiがGX Simulator3との通信を開始します。
GX Simulator3との接続が完了しましたら、Gemini上の変数とGX Simulator3のデバイスのペアリングを行います。
まずGeminiからGX Simulator3に送る信号を設定します。
[シミュレーションからサーバへ]を右クリックし、[変数を追加]を選択します。
左側にGemini、右側にGX Simulator3のデバイスが表示されますので、Gemini側のX100とGX Simulator3側の「X100」を選択し、[選択済みペア]をクリックします。
同様に「X101」と「X102」もペアリングします。
次にGX Simulator3からGeminiに送る信号を設定します。
[サーバからシミュレーションへ]を右クリックし、[変数を追加]を選択します。
先ほどと同様に「Y101」と「Y102」をそれぞれペアリングします。
次に[ビヘイビア]の中の「サーボコントローラ」の"J1"軸と「D1000」、"J2"軸と「D2000」をそれぞれペアリングします。
以上で接続設定が完了しました。
シミュレーションの起動
実際にシミュレーションを実行します。
まずGeminiのシミュレーションを開始します。
次にGX Simulator3で「M300」の"原点復帰起動"をONにし、「M406」の"原点復帰全完了"がONになったら「M300」をOFFにします。
「M101」をONにすると、自動回路が走り始めるので、「D1000」と「D2000」の値が変化することを確認します。
Geminiの画面に戻ります。
画面下側にある接続済変数画面の左側がGeminiで右側がGX Simulator3の値となります。
シミュレータ側から現在地の値を受け取って動作していることが分かります。
センサーの「X100」に関してもフレームに接触したことを検知するとシミュレータ側に出力されていることが確認できます。
以上で、MELSOFT Geminiを用いた装置シミュレーション方法についての説明を終わります。

=================================================================================



■MELSOFT Gemini 使用方法解説動画テキスト
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/howto.html

=================================================================================

2D平面図を作成してみよう

Geminiで作成したレイアウトを2DCADファイルに出力する方法
https://youtu.be/eEwpOGJ-070

本動画では、Geminiで2D平面図を作成する方法について説明します。
2D平面図は、コンポーネントを配置する時などで役に立ちます。
まず、レイアウトを2D平面図でエクスポートする方法から説明します。
簡単なレイアウトを構築します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Feeders]から「Basic Feeder」を3Dワールド上にドラッグ&ドロップします。
[タイプ別モデル]-[Conveyors]から「Conveyor」を3Dワールド上にドラッグ&ドロップします。
[ホーム]タブ-[マニピュレーション]-[PnP]を選択した状態で「Conveyor」を「Basic Feeder」に近づけ、接続します。
これで、エクスポート用のレイアウトが構築できました。
レイアウトを2D平面図でエクスポートします。
[図面]タブをクリックします。
[ビューをクリエイト]をクリックすることで、3Dワールド上のレイアウトから、指定した視点の図面を作成できます。
今回は[上部]をクリックします。
図面が生成されます。
[図面プロパティ]ウィンドウから、大きさなどの設定ができます。
今回は、初期設定のまま使用します。
[エクスポート]-[図面]をクリックし、[図面をエクスポート]ウィンドウから[ファイル形式]を"Autodesk RealDWG(AutoCAD) (*.dxf)"に変更して[エクスポート]をクリックします。
任意の名前でファイルを保存してください。
これで、3Dレイアウトを2D平面図でエクスポートできました。
エクスポートしたファイルを使って、3Dワールド上に2D平面図をインポートしてみましょう。
[ホーム]タブをクリックします。
Ctrl+Nキーをクリックして、一度レイアウトをクリアします。
[ホーム]タブ-[インポート]-[ジオメトリ]をクリックします。
先ほど保存した2D平面図を選択して、"開く"をクリックします。
[モデルをインポート]ウィンドウから、インポート時の設定ができます。
今回は、全てデフォルトのままで[インポート]をクリックします。
3Dワールド上に、先ほど作成した2D平面図が追加されます。
視認性が悪い場合、[ファイル]タブ-[オプション]-[ディスプレイ]から[フロアの色]を変更してください。
追加した2D平面図に対して、[ツール]の[スナップ]や[整列]を使ってコンポーネントを配置できます。
2D平面図を使用して、再度レイアウトを作成します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Feeders]から"Basic Feeder"を3Dワールド上にドラッグ&ドロップします。
[ツール]-[整列]をクリックします。
「Basic Feeder」のフレーム-2D平面図の順にクリックして、「Basic Feeder」を移動させます。
[タイプ別モデル]-[Conveyors]から「Conveyor」を3Dワールド上にドラッグ&ドロップします。
[ホーム]タブ-[マニピュレーション]-[PnP]を選択した状態で「Conveyor」を「Basic Feeder」に近づけ、接続します。
これで、インポートした2D平面図を使ってコンポーネントを配置できました。
以上で、「Geminiで2D平面図を作成してみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

AGVが製品をピック&プレースする時の位置を変更しよう

AGVが製品を積む、降ろす時の一時停止位置を変更する方法
https://youtu.be/oCRqkbyDPcQ
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_044.zip

本動画では、AGVが製品をピック/プレースするなどの作業を行う時の作業位置や体の向きを変更する方法について説明します。
まず初めに、「AGVが製品をピック_プレースする時の位置や向きを変更しよう.vcmx」を開きます。
このプロジェクトでは、シミュレーションを再生すると"Feeder Process"から"Manual Process"へAGVが製品を輸送します。
3Dツールバーの"フレームタイプ"をクリックします。
AGVが製品をピック/プレースする時に、各コンポーネントで設定する"Resource Location"へ移動し、矢印の向きに方向転換しています。
AGVが製品をピック/プレースする位置や向きは、この"Resource Location"に関係するプロパティで決定します。
フレームタイプをクリックして非表示にします。
[Resource Location]について説明します。
"Resource Location"とは、プロセスを持つコンポーネントで設定する、AGVなどが作業を行う時の基準となる位置です。
コンポーネントの近くに矢印アイコンで表示され、[既定]タブから設定を変更できます。
「Feeder Process」をクリックし、[コンポーネントプロパティ]ウィンドウ-[既定]タブを開きます。
[ResourceApproach]は、選択した向きになるように[ResourceOffset]の位置と(Tx/Ty/Tz)と角度 (Rx/Ry/Rz)を変更します。
[ResourceOffset]は、コンポーネントの原点を基準としたオフセット位置と角度の設定です。
この値で"Resource Location"の位置と向きが決まります。
[ResourceApproach]を変更して、シミュレーションを再生します。
[ResourceOffset]の角度の設定が変わったため"Resource Location"の向きが変わり、AGVが製品をピックするときの向きが変更できました。
AGVが実際に作業を行う位置は、トランスポートコントローラで設定します。
「Mobile Robot Transport Controller」をクリックして、[コンポーネントプロパティ]ウィンドウ-[Link Defaults]タブをクリックします。
"ResourcePickOffset/ResourcePlaceOffset"は、「ResourceLocation」を基準としたオフセットで、トランスポートコントローラに接続しているAGVなどが実際に作業を行う位置になります。
"Pick/PlaceApproach"は、AGVなどが実際の作業位置へ移動する時、または作業位置から離れる時の中継地点となる位置です。
[ResourcePickOffset]と"PickApproach"の値を変更して、シミュレーションを再生します。
AGVが製品をピックする時の位置が変更できました。
また、AGVがピックする位置へ向かう時と、ピックする位置から離れる時の、中継地点も変更できました。
先ほど変更した、[LinkDefault]タブのプロパティ値はトランスポートリンクで使用されます。
[プロセス]タブをクリックします。
[エディタ]-[フロー]をクリックし、"Feeder-ManualProcess"間のひし形アイコンをクリックします。
[プロパティ]ウィンドウの各値に、"LinkDefaults"で定義した値が設定されています。
また、トランスポートリンクの[UseCustomParameters]にチェックを入れることで、このトランスポートリンクのみ個別に設定が変更できます。
以上で、「AGVが製品をピック＆プレースする位置を変更しよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

AGVに障害物を検出させたり、移動範囲を制限したりしてみよう

AGVに障害物を検出させる方法と、AGVの移動範囲を制限する方法
https://youtu.be/LMi3iqkqqN8
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_045.zip

本動画では、AGVが移動する際に障害物を自動回避するようにしたり、AGVの移動範囲を制限したりする方法について説明します。
AGVに障害物を検出させたり、「移動範囲を制限したりしてみよう.vcmx」を開きます。
シミュレーションを再生します。
「Feeder Process」から「Sink Process」へ「Mobile Robot Resource」が製品を輸送します。
障害物があった時のリソースの移動について説明します。
「Feeder Process」と「Sink Process」の間にコンポーネントを配置して、動作を確認します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Facilities - Factory]から"Wall"を3Dワールド上にドラッグ&ドロップします。
[コンポーネントプロパティ]ウィンドウから[WallLength]を「6000」、[マテリアル]を「yellow」に変更します。
ドラッグして、「Feeder Process」と「Sink Process」の間に配置します。
シミュレーションを再生します。
「Mobile Robot Resource」が製品を輸送する際に、「Wall」を迂回して移動します。
これは、「Mobile Robot Transport Controller」が「Wall」を障害物として検出したからです。
「Mobile Robot Transport Controller」をクリックし、[コンポーネントプロパティ]ウィンドウ-[既定]タブをクリックします。
障害物を検出するには、トランスポートコントローラに移動範囲を指定する必要があります。
移動範囲を指定することで、その移動範囲上にある静的コンポーネントを障害物として検出できるようになります。
[UseGlobalArea]は、移動範囲として3Dワールド全体を指定する設定です。
この設定が有効の場合、シミュレーション再生時に3Dワールド上の静的コンポーネントを検出します。
リソースが移動する時、検出したコンポーネントを回避するようになります。
[UseGlobalArea]を無効にして、再度シミュレーションを再生します。
「Mobile Robot Resource」は「Wall」を突っ切って移動します。
[UseGlobalArea]に再度チェックをいれます。
[既定]タブの障害物を検出するためのプロパティについて説明します。
[ObstacleHorizontalClearance]は、障害物とリソースとの水平方向の接触を避ける間隔の設定です。
[ObstacleVerticalClearance]は、障害物とリソースとの垂直方向の接触を避ける間隔の設定です。
[ExcludeObstacles]は、障害物に含めないコンポーネントの設定です。
[PrecisionObstacles]は、より詳細に分析を行う障害物となるコンポーネントの設定です。
複雑な形状のコンポーネントを障害物として設定したい場合に使用します。
設定を変更して、動作を確認します。
「Wall」をドラッグして位置と向きを変更し、「Mobile Robot Resource」が下を通れるように変更します。
シミュレーションを再生します。
「Mobile Robot Resource」が「Wall」の下を通って移動します。
「Mobile Robot Transport Controller」をクリックし、[コンポーネントプロパティ]ウィンドウ-[既定]タブから[ObstacleVerticalClearance]を"3000"に変更します。
シミュレーションを再生します。
「Wall」が障害物として検知されるようになり、「Mobile Robot Resource」が移動する時、迂回するようになります。
「Mobile Robot Transport Controller」をクリックし、[コンポーネントプロパティ]ウィンドウ-[既定]タブから[ExcludeObstacles]に"Wall"を追加します。
「Wall」を最初の配置に戻します。
シミュレーションを再生します。
「Wall」を障害物に含めなくなったため、「Mobile Robot Resource」が移動する時、「Wall」を突っ切ります。
リソースの移動範囲を設定する方法を説明します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Resource Utilities]から「Pathway Area」を3Dワールド上にドラッグ&ドロップします。
「Pathway Area」は、トランスポートコントローラとインターフェース接続することで、リソースの移動範囲として設定できるコンポーネントです。
複数の「Pathway Area」を重ね合わせて配置することで、"Pathway Area"間でリソースが移動できるようになります。
配置した「Pathway Area」は、[ホーム]タブ-[マニピュレーション]-[インタラクティブ]をクリックし、黒色の部分をドラッグすることでサイズを変更できます。
「Pathway Area」上の移動方向を一方向にする場合、「Pathway Area」をクリックし[コンポーネントプロパティ]ウィンドウ-[既定]タブから[OneWay]にチェックを入れます。
[OneWay]を有効にすると、表示された三角マークの方向にのみリソースが移動するようになります。
移動方向を変更する場合は、[OneWayHeading]を変更します。
「Pathway Area」をコピー&ペーストなどで複数配置し、PickからPlaceへの移動経路を設定します。
配置した「Pathway Area」とトランスポートコントローラをインターフェース接続します。
3Dワールド上の全ての「Pathway Area」を接続する場合は、トランスポートコントローラの[既定]タブで一度に接続ができます。
「Mobile Robot Transport Controller」をクリックします。
[コンポーネントプロパティ]ウィンドウ-[既定]タブから"Connect All Pathways"をクリックします。
シミュレーションを再生します。
「Mobile Robot Resource」が、設定した「Pathway Area」上を移動するようになります。
以上で、「AGVに障害物を検出させたり、移動範囲を制限したりしてみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

AGVの輸送を制御してみよう

ChargeOnIdleはGemini1.48以降の機能です。
AGV同士の衝突を回避する方法やAGVの状態を制御する方法
（関連動画：AGVに障害物を検出させたり、移動範囲を制限したりしてみよう、リソースとコントローラーの設定項目について知ろう(3/4)、アイドリングと充電の設定をしてみよう、自動ドアを作ってみよう(1/2)）
https://youtu.be/oC_5j0H-KmM
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_150.zip

本動画では、AGVの輸送を制御する時に、AGV同士の衝突を回避する方法やAGVの状態を制御する方法について説明します。
初めに、「AGVの輸送を制御してみよう.vcmx」を開きます。
[ホーム]タブ-[グリッドスナップ]から[自動サイズ]のチェックが外れており、[常にスナップ]のチェックが入っていることを確認します。
但しコンベア等を接続する場合は[常にスナップ]のチェックを外してから実施してください。
AGVの動作について説明します。
[Mobile Robot Transport Controller]を選択し、AGVの近くに配置しておきます。
シミュレーションを再生するとAGV同士が干渉していることが分かります。
またAGVが先ほど移動した[Mobile Robot Transport Controller]を障害物として検知し、避けて移動していることが分かります。
これは、シミュレーション再生時に自動的に生成されるナビゲーションメッシュによるものです。
ナビゲーションメッシュは障害物に基づいて算出され、リソースが実際に移動できる範囲を示しています。
リソースは人やAGVを指します。
ナビゲーションメッシュは、[Mobile Robot Transport Controller]の[コンポーネントプロパティ]ウィンドウ-[既定]タブにある[Show Navigation Mesh]ボタンを押下することで確認することができます。
シミュレーションをリセットします。
[Mobile Robot Transport Controller]の[UseGlobalArea]のチェックを外してシミュレーションを再生するとAGVは[Mobile Robot Transport Controller]を障害物として認識しなくなり避けることなく通過をしてしまいます。
ナビゲーションメッシュはリソースの移動範囲から障害物を検出して生成されます。
リソースの移動範囲はTransport Controllerが接続しているPathwaysに基づいて生成されます。
Pathwaysに接続が無い場合はGlobalAreaを使用して移動範囲を決定します。
[UseGlobalArea]にチェックが入っている場合は3Dワールド全体を移動範囲として指定している状態となります。
チェックを外すことで、移動範囲の指定が解除され、障害物を検出しなくなります。
その結果リソースは障害物を検出できずこの様に避けることなく移動する動作となります。
次に障害物の設定について説明します。
シミュレーションをリセットします。
今までの変更を元に戻すためTransport Controllerの位置を戻して、[UseGlobalArea]にチェックを入れてください。
何も設定をしていない状態ではコンポーネントは全て障害物として検出されます。
障害物から除外したい場合はTransport Controllerの[ExcludeObstacles]プロパティを使用します。
[ExcludeObstacles]プロパティのリストに追加されたコンポーネントは障害物として検出されなくなります。
シミュレーション再生中にTransport Controllerの[Show Obstacles]ボタンを押下することで障害物を視覚的に確認できます。
透明な赤色の表示は、障害物のバウンディングボックスを示します。
透明な黄色の表示は、リソースとのクリアランスを含めた障害物のバウンディングボックスを示します。
リソースと障害物とのクリアランスはTransport Controllerの[ObstacleHorizontalClearance]プロパティで水平方向の、[ObstacleVerticalClearance]プロパティで垂直方向の設定ができます。
現状のモデルではAGVはドアやフェンスの下からではなくフェンスを迂回して移動をしています。
これは配置されているドアやフェンスを障害物として検出しておりそれらを避ける経路をとっているためです。
AGVがドアやフェンスを通過するように設定します。
シミュレーションをリセットし、Transport Controllerの[Clear]ボタンを押下して障害物の視覚化を解除してください。
Transport Controllerの[PrecisionObstacles]プロパティを使用してドアとフェンスを通過可能な障害物として定義します。
[PrecisionObstacles]は複雑な形状のコンポーネントを障害物として設定したい場合に使用します。
[PrecisionObstacles]プロパティに設定されたコンポーネントは形状を詳細に分析し、障害物内を移動できるようになります。
[PrecisionObstacles]プロパティにドアとフェンスを追加します。
[ObstacleHorizontalClearance]プロパティを200、[ObstacleVerticalClearance]プロパティを0に設定します。
シミュレーションを再生します。
先ほどと異なりAGVが迂回をせずにフェンスの下を通過するようになります。
次にAGV同士の移動中の干渉を回避させます。
シミュレーションをリセットします。
Transport Controllerの[Avoidance]タブを開きます。
[Enabled]プロパティにチェックを入れてAvoidance機能を有効化します。
シミュレーションを再生します。
機能を有効化することでAGVはお互いに衝突や干渉することを回避するようになります。
但しAGV同士がどの様にしても衝突を回避できない場合、デッドロックが発生しAGVが停止してしまいます。
シミュレーションをリセットします。
[IgnoreDeadLocks]プロパティにチェックを入れることで、作業中のリソース同士でデッドロックが発生した時に、"StopTimer"で設定した時間経過後、デッドロックを無視して移動できるようになります。
シミュレーションを再生します。
作業を行っているAGV同士のデッドロックは回避できましたが、画面のようにアイドル中のAGVと作業中のAGVでのデッドロックはまだ発生してしまいます。
これを回避するためにPM Navigationの[Pathway Area]と[Pathway Curve]を使用します。
シミュレーションをリセットします。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Navigation]から[Pathway Area]を選択して3Dワールド上にドラック&ドロップで追加します。
[Pathway Area]はTransport Controllerとインターフェース接続をすることで、リソースの移動範囲として設定できるコンポーネントです。
複数の[Pathway Area]を使用することで[Pathway Area]間でリソースが移動できるようになります。
[Pathway Area]の[AreaLength]プロパティと[AreaWidth]プロパティでエリアのサイズを調整できます。
それぞれ2000mmに設定します。
サイズ調整した[Pathway Area]をフェンスの間に移動します。
次にパターンの説明をします。
パターンは指定した方向に選択したコンポーネントをコピーする機能です。
先ほど追加した[Pathway Area]を選択した状態で[ホーム]タブ-[ツール]-[パターン]を押下します。
[パターン]ウィンドウから[カウント]プロパティを5に設定して[適用する]ボタンを押下します。
[パターンに沿って]プロパティを「-Y」に変更して同じ様に[適用する]ボタンを押下します。
不要な[Pathway Area]を削除します。
対象の[Pathway Area]を選択し、Ctrlキーを押下したまま複数選択後、Deleteキーで削除します。
eカタログ-タイプ別モデル- PM Navigationから[Pathway Curve]を選択して3Dワールド上にドラック&ドロップで追加します。
[Pathway Curve]も[Pathway Area]と同様にTransport Controllerとインターフェース接続をすることで、リソースの移動範囲として設定できるコンポーネントです。
追加したPathway Curveの角度を180°回転させます。
[コンポーネントプロパティ]ウィンドウから[AreaWidth]プロパティを2000mmに設定します。
位置を移動して、PathwayAreaと並ぶように配置します。
次にAGVのアイドル位置を設定します。
[ホーム]タブ-[マニピュレーション]-[インタラクティブ]を選択します。
[Pathway Area]を選択し、濃い灰色の四角をドラッグしてサイズを小さくします。
この時AGVが経路として利用できないように[Pathway Curve]やピッキングエリア付近の[PathWayArea]から離すようにサイズを調整してください。
次に[Pathway Area]とTransport Controllerの接続を行います。
Transport Controllerをクリックして、[コンポーネントプロパティ]ウィンドウ-[既定]タブにある[Connect All Pathways]ボタンを押下します。
PathwayすべてがTransport Controllerに接続されます。
画面下の[出力]ウィンドウに接続されたことを示すメッセージが表示されます。
シミュレーションを再生すると各AGVが追加した[Pathway Area]上を移動するようになったのが分かります。
ナビゲーションメッシュを表示してみます。
AGVの移動経路は[Pathway Area]のエッジの周りを移動しているため、AGVが経路の中心を移動するように設定をします。
シミュレーションをリセットします。
[セルグラフ]-[PM Navigation]を選択して、すべての[Pathway Area]を選択状態にします。
[Pathway Curve]は選択状態を解除します。
[Pathway Curve]は常に中心線の始点と終点から接続されており、AGVは経路の中心を移動するためです。
[コンポーネントプロパティ]ウィンドウ-[CenterlineConnect]プロパティにチェックを入れます。
シミュレーションを再生してナビゲーションメッシュを表示します。
AGVが経路の中心を移動するようになりました。
次にAGVが1方向のみを移動するように設定をします。
シミュレーションをリセットします。
対象の[Pathway Area]を選択後、Ctrlキーを押下したまま5つの[Pathway Area]を選択します。
[コンポーネントプロパティ]ウィンドウ-[OneWay]プロパティにチェックをいれます。
選択した経路の中央に進行方向の矢印が表示されます。
一方通行の進行方向を変更します。
ドアの前の[Pathway Area]を選択し、[コンポーネントプロパティ]ウィンドウ-[OneWayHeading]プロパティを「-Y」に変更します。
Ctrlキーを押下したまま3つの[Pathway Area]を選択し、[OneWayHeading]プロパティを「+Y」に変更します。
シミュレーションを再生して動作を確認します。
AGVは指定した中心線と一方通行制限を遵守するようになります。
シミュレーションをリセットして再度再生し、数秒後に一時停止します。
AGVは指定した中心線と一方通行制限を遵守していますが、キュー内の最後のAGVが他のAGVを通り抜けて、最初にピッキングエリアに移動してしまいます。
リソースの優先順位について確認します。
シミュレーションをリセットします。
Transport Controllerを選択し、[コンポーネントプロパティ]ウィンドウの[既定]タブにある、リソースの優先順位を表す、[ResourcePriority]プロパティに、「Nearest」が選択されているため、ピッキングエリアに最も近い、キューの最後のAGVが最初に移動しています。
[ResourcePriority]プロパティを、[Shortest Travel]に変更することでこの問題を解決できます。
シミュレーションを再生すると、ピッキングエリアまでの経路で移動距離が最も短い、キューの最初のAGVにリソースが割り当てられます。
次にキューの2番目のAGVにリソースが割り当てられます。
しかし、ここで渋滞が発生しているため、アイドル状態の2 つのAGVを通行の邪魔にならないように移動する必要があります。
これを修正するには、AGVがアイドル状態のときに移動できるアイドルロケーションを追加します。
シミュレーションをリセットします。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Navigation]から[Idle location]を3Dワールドに追加し、先ほどサイズ変更した[Pathway Area]にスナップしてからRzを180に変更し、コピーします。
サイズを変更したもう一つの[Pathway Area]にコピーしたidle locationをスナップします。
次に、これらのidle locationを接続するには、Transport Controllerを選択し、[コンポーネントプロパティ]ウィンドウ-[既定]タブにある[Connect All Idle And Charging Locations]ボタンをクリックします。
シミュレーションを再生します。
ここで、キュー内の最後の2つのAGVは、アイドル遅延時間が経過した後にアイドル状態になります。
現在アイドル状態であるAGVを選択します。
[コンポーネントプロパティ]ウィンドウの[既定]タブにある[TimeToIdle]で、アイドル遅延時間は現在10秒であることが分かります。
また、AGVの状態は、[CurrentState]プロパティで確認でき、現在はアイドル状態であることがわかります。
バッテリーの状態を表示する[Power]タブでは、現在の容量が1時間あたりのアイドル消費量によって定義される割合で減少していることがわかります。
アイドリング時のバッテリーレベルを上げるために、アイドル時の充電を有効にします。
シミュレーションをリセットします。
AGVを選択し、Ctrlキーを押下したまま AGVをすべて選択します。
[Power]タブから[ChargeOnIdle]を有効にします。
また、eカタログからCharging locationを3Dワールドに追加するか、[idle location]の充電を有効にする必要があります。
今回は[idle location]の充電を有効にします。
[idle location]を選択し、Ctrlキーを押下したままもう一方の[idle location]を選択し、[コンポーネントプロパティ]ウィンドウから[Charger]プロパティを有効にします。
シミュレーションを再生します。
AGVがアイドル位置にあるとき、[コンポーネントプロパティ]の[既定]タブから、現在の状態がアイドル状態か充電中かを確認できます。
現在4台のAGVに対して[idle location]は2箇所だけです。
つまり、3 台がアイドル状態である場合、3 台目はビジー状態のAGVの通行を妨げる可能性があります。
もちろん、[idle location]をもう1箇所追加するという選択肢もありますが、今回は[Idle Path]を使用して解決します。
[Idle Path]は、AGVがアイドル状態の時に特定のパスでループさせることができます。
シミュレーションをリセットします。
[eカタログ]ウィンドウから[Idle Path]を3Dワールドに追加します。
[コンポーネントプロパティ]ウィンドウ-[既定]タブから[Capacity]プロパティを「1」に設定します。
一度に1つのリソースだけが経路上でアイドル状態になるようにします。
[Add Waypoint]ボタンをクリックして、作成された[Idle Path Waypoint]を[Idle Path]の開始位置に移動させます。
再度、[Add Waypoint]ボタンをクリックして、もう1つ[Idle Path Waypoint]を作成します。
追加した[Idle Path Waypoint]を[Idle Path]の終了位置に移動させます。
アイドル中にリソースが指定したパス上を移動するループを定義するには、2 つの[Idle Path Waypoint]で十分です。
最後にTransport Controllerを選択し、新しいidle locationを接続します。
[既定]タブの[Connect All Idle And Charging Locations]ボタンをクリックします。
アイドルしやすくさせるため、一旦、[idle location]を1つ削除します。
シミュレーションを再生して結果を確認します。
追加したWaypointを通るパスに沿ってAGVがアイドリングし始めることがわかります。
シミュレーションをリセットします。
コントロール+Zキーを押下して、[idle location]をもとに戻します。
次に、ピッキングエリアの周囲で衝突が発生する可能性があるため、[Pathway Area]の容量を制御することでこれを回避します。
ピッキングエリアに最も近い[Pathway Area]を選択し、Ctrl キーを押したまま隣接する2つの[Pathway Area]を選択します。
[コンポーネントプロパティ]ウィンドウから[LimitCapacity]にチェックをいれ、表示された[Capacity]に「1」を設定します。
これにより、3つの[Pathway Area]のそれぞれが、一度に最大1つのリソースを許可する設定になりました。
また、2つの[Pathway Area]を組み合わせることで、AGVのピッキングスペースをより多く確保できます。
eカタログのPM Navigationから[Pathway Capacity Group]を追加します。
リボンの[接続]-[インターフェース]をクリックし、ピッキングエリアに最も近い2つの[Pathway Area]と接続します。
[接続]-[インターフェース]をクリックし、インターフェースを非表示にします。
シミュレーションを再生し、動作を確認します。
AGVのピッキングスペースが広く確保できています。
最後に、[Pathway Area Sensor]を使用してドアを自動的に開閉する方法を確認します。
シミュレーションをリセットします。
[eカタログ]ウィンドウから[Pathway Area Sensor]を3Ｄワールドに追加します。
カメラの位置を調整して、これから設定する[Pathway Area]を見やすくします。
次に、[Pathway Area Sensor]のクイックメニューにあるインターフェースアイコンをクリックします。
[Pathway Area2，3，4，8]をクリックし、[Pathway Area Sensor]と接続します。
インターフェースを非表示にします。
これにより、センサーがそのエリアを通過するリソースを検出できるようになりました。
[接続]-[シグナル]をクリックします。
[Pathway Area Sensor]の[ResourceDetected]と[Rolling Steel Door v2]の[IN_J1 Action]を接続します。
これにより、センサーがエリアに進入するリソースを検出するとドアが開き、リソースが離れるとドアが閉じます。
リボンの[接続]グループから[シグナル]をクリックし、シグナルを非表示にします。
[Rolling Steel Door v2]を選択し、[コンポーネントプロパティ]ウィンドウにある[J1]の値を「0」に変更して、デフォルトでドアが閉じているようにします。
視点を元に戻して、シミュレーションを再生します。
センサーが反応してドアが自動的に開閉されます。
シミュレーションの再生中または一時停止中にトラフィックを視覚化できます。
Transport Controllerを選択し、[コンポーネントプロパティ]ウィンドウ-[既定]タブから[Show All Traffic]ボタンをクリックすると、すべてのトラフィック情報が表示されます。
太線は、交通量が多い場所を示しています。
これは現在のシミュレーションのスナップショットであるため、更新するには、[Show All Traffic]ボタンを再度クリックします。
以上で、「AGVの輸送を制御してみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

AGVの輸送方法を変更してみよう

AGVに輸送タスクを割り当てる時のルールと、搬入元・搬出先が複数存在する時の搬送ルールの変更方法
https://youtu.be/znwZWxD9bpM
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_093.zip

本動画では、輸送タスクやAGVが複数ある場合の、輸送方法の変更の仕方を説明します。
まず初めに、「AGVの輸送方法を変更してみよう.vcmx」を開きます。
シミュレーションを再生します。
2台の「Mobile Robot Resource」が製品を輸送します。
輸送タスクの割り当て方について説明します。
輸送タスクをどのような手順で各「Mobile Robot Resource」に割り当てるかは、「Mobile Robot Transport Controller」の[ResourcePriority]で定義します。
「Mobile Robot Transport Controller」を選択して、[コンポーネントプロパティ]ウィンドウ-[既定]タブを開きます。
[ResourcePriority]は、輸送タスクをリソースに割り当てる時の手順を定義します。
"None"の場合は、コントローラのインターフェースに接続した順番に、リソースに割り当て可能かを確認し、可能なリソースから順に輸送タスクを割り当てます。
"Nearest"の場合は、搬入元に近いリソースから割り当て可能かを確認し、輸送タスクを割り当てます。
[ResourcePriority]を"Nearest"に変更して、シミュレーションを再生します。
「Feeder Process」へは、より近い位置にある「Mobile Robot Resource」が向かいます。
「Mobile Robot Resource」をドラッグして「Feeder Process」から距離を離して配置し、再度シミュレーションを再生します。
「Feeder Process」へは、より近い位置にある「Mobile Robot Resource #2」が向かいます。
"Least Utilized"の場合は、接続している各「Mobile Robot Resource」の利用状況などの統計情報をもとに、最も利用されていないリソースから割り当て可能かを確認し、タスクを割り当てます。
輸送タスクの割り当て方についての説明は、以上になります。
次に、輸送タスクで製品の搬入元・搬出先が複数存在する時のルールについて説明します。
輸送タスクで製品の搬入元・搬出先が複数存在する時のルールは、「Mobile Robot Transport Controller」の[Strategy]で定義します。
"Strategy"は、輸送タスクを行う時に製品の搬入元、製品の搬出先が複数ある場合、どのように輸送タスクを行うか定義します。
"One-to-One"の場合は、1つのプロセスから製品を搬入し、1つのプロセスへ製品を搬出します。
"One-to-Many"の場合は、1つのプロセスから製品を搬入し、複数のプロセスへ製品を搬出します。
"Many-to-One"の場合は、複数のプロセスから製品を搬入し、1つのプロセスへ製品を搬出します。
"Many-to-Many"の場合は、複数のプロセスから製品を搬入し、複数のプロセスへ製品を搬出します。
今回は、"One-to-Many"を選択します。
一度の輸送タスクで複数の製品を扱えるようにするために、「Mobile Robot Resource」が複数の製品を持てるようにします。
輸送タスクで製品を持つ時の設定は、[Transport]タブで定義します。
「Mobile Robot Resource」をクリックして、[コンポーネントプロパティ]ウィンドウ-[Transport]タブをクリックします。
今回設定を変更する、[Transport]タブのプロパティについて説明します。
"Capacity"は、「Mobile Robot Resource」が1度に持つことができる製品の上限数を定義します。
"TransportLocation"は、「Mobile Robot Resource」に製品を配置する時の、1つ目の製品の位置を定義します。
"Pattern"は、製品を複数配置する時に、各軸に配置できる個数を定義します。
"PatternStep"は、製品を複数配置する時の、製品間の間隔を定義します。
"TransportLocation"を基準にして決まります。
プロパティを変更して、「Mobile Robot Resource」が製品を2つ持てるようにします。
[Capacity]を"2"に変更します。
[TransportLocation]の[Ty]を"200"に変更します。
[Pattern]の[Y]を"2"に変更します。
[PatternStep]の[Y]を"350"に変更します。
これで、「Mobile Robot Resource」が製品を2つ持てるようになりました。
最後に、設定を変更していないMobile Robot Resourceとコントローラとのインターフェース接続を解除します。
「Robot Transport Controller」を選択した状態で、[ホーム]タブ-[インターフェース]をクリックします。
「Robot Transport Controller」の"Resources"と「Mobile Robot Resource #2」を結ぶ線をクリックして、接続を解除します。
シミュレーションを再生します。
「Mobile Robot Resource」が製品を輸送する時に、1つのプロセスで2つ搬入し、別々のプロセスへ1つずつ搬出するようになりました。
以上で、「AGVの輸送方法を変更してみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

Crossing Conveyorを使ってみよう

4つの方向に製品を分岐できるコンベア（Crossing Conveyor）の使用方法
https://youtu.be/2Ejqz5u7JyI

本動画では、[Crossing Conveyor]について説明します。
[Crossing Conveyor]とは、4つの入力のいずれかから、4つの出力のいずれかに製品を分配できるコンベアです。
[Crossing Conveyor]に[Conveyor]を[PnP]で接続します。
プロセスモデリングで使用する場合、「From Conveyor Process」、「To Conveyor Process」、「Feeder Process」等を[PnP]で直接接続すると、リフトが動作しないことがあります。
正常な場合は[Cylinder]はLeft、[Bottle]はRightの方向へ流れますが、リフトが動作せずBackの方向へ流れることがあります。
必ず「Conveyor」等を間に挟んで接続します。
正常に製品が流れることが分かります。
プロセスモデリングで使用しない場合、[Basic Feeder]等を直接接続しても停止することはありません。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Conveyors]-[Visual Compornents]から、[Conveyor]と[Crossing Conveyor]を3Dワールドにドラッグ＆ドロップします。
[マニピュレーション]グループの[PnP]を選択して、[Crossing Conveyor]に接続します。
[Crossing Conveyor]のプロパティについて説明します。
3Dワールドの[Crossing Conveyor]を選択し、[コンポーネントプロパティ]ウィンドウを開きます。
[既定]タブの[LiftJoint]はリフトの高さを変更できます。
シミュレーション開始前に高さを設定しておくと、その位置からシミュレーションを開始することも可能です。
[マニピュレーション]グループの[インタラクティブ]を使用し、リフトを動作させることも可能です。
製品の流れる方向が「Front」または「Back」の場合は[Down]、「Left」または「Right」の場合は[Up]の高さまでリフトが動作し、製品が流れます。
[Down]は0の位置、[Up]は「[Advanced]タブの[RollerRadius]の値/2+[既定]タブの[LiftOffset]の値」の位置です。
[LiftOffset]の値はマイナス値も設定可能です。
リフトの可動範囲は、0から999mmまでです。
[Up]の値が可動範囲を超えた時、[プログラム]タブの[リミット]グループにある[リミットで停止]にチェックが入っている場合、シミュレーションは停止します。
リフトの移動時間は[LiftDelay]に従います。
リフトの待機位置は[LiftHome]で設定できます。
[LiftHome]が[Down]の場合、製品を「Front」から「Right」へ流し、リフトの動作を確認します。
シミュレーション開始時、リフトはDownの位置で待機します。
製品がリフト上に移動完了した時、リフトが[Up]の位置まで上昇します。
リフトは、[Up]の位置まで移動しましたが、製品が次のコンベアに移動しません。
[LiftDelay]で設定された時間待機し、製品は「Right」の方向へ移動開始します。
製品がCrossingConveyorから搬出され、リフトがDownの位置へ移動することがわかります。
[ConveyorLength]、[Width]、[Height]は、[Crossing Conveyor]のサイズを変更できます。
それぞれ値を1000に変更します。
[Conveyor]を[Crossing Conveyor]と接続し直すと、接続した[ConveyorLength]、[Width]、[Height]は[Crossing Conveyor]と同じ値になります。
再度、[Crossing Conveyor]を選択します。
[ConveyorSpeed]、[BeltSpeed]は、製品が[Conveyor]上を流れる速度を変更できます。
[Feeder]と[Crossing Conveyor]を接続し、速度を変更します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Conveyors]-[Visual Compornents]から、[Conveyor]を2つ、3Dワールドにドラッグ＆ドロップします。
[Conveyor]の矢印が[Crossing Conveyor]の外側へ向くように[PnP]で接続します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Flow Components]から、[Feeder]を3Dワールドにドラッグ＆ドロップします。
[Crossing Conveyor]に[PnP]で接続します。
[Crossing Conveyor]を選択し、シミュレーションを実行します。
[コンポーネントプロパティ]ウィンドウの[既定]タブにある[ConveyorSpeed]、[BeltSpeed]の値を変更します。
それぞれ値を500に変更します。
[Crossing Conveyor]の[Conveyor]と[Belt]の速度が変化したことが分かります。
シミュレーションをリセットします。
[コンポーネントプロパティ]ウィンドウの[ShowSupport]は、支柱の表示、非表示を変更できます。
[AutoProperties]は、[PnP]でConveyor等を接続した際に接続した先のプロパティ[ConveyorLength]等と同じ値に自動で変わります。
[ShowPortNames]は、CrossingConveyorに存在する接続場所の名前を表示、非表示に変更できます。
[ControlMode]は、ルーティングルールかシグナルで製品の流れを制御できます。
ルーティングルールについての詳細は、FAサイトの使用解説動画「製品ごとに輸送経路を変えてみよう」を参照ください。
シグナルで製品の流れを制御するため、[ControlMode]で[Signal Control]を選択します。
[接続]グループにある[シグナル]を選択することで、シグナルエディタを表示できます。
シミュレーションを実行します。
[出力]ウィンドウにルーティングルールが使用されていないことと、製品の流れる方向が表示されます。
コンベアとベルトの方向を確認するため、[シグナルを接続]ウィンドウ下の[コンポーネントプロパティ]を選択します。
製品が[Crossing Conveyor]上を流れている状態で、シグナルエディタの[ConveyorDirection]をオフに変更します。
製品が後退し、シグナルをオフにしたことで、[コンポーネントプロパティ]ウィンドウの[ConveyorDirection]も[Backward]に変更されます。
[BeltDirection]も確認するため、[ConveyorDirection]をオンに戻します。
シグナルエディタの[LiftStateUp]をオンに変更します。
製品が[Crossing Conveyor]のRightの方向へ流れることが分かります。
シグナルエディタの[BeltDirection]をオフに変更します。
製品がLeftの方向へ流れ、シグナルをオフにしたことで、[コンポーネントプロパティ]ウィンドウの[BeltDirection]も[Left]に変更されます。
シミュレーションをリセットします。
[接続]グループの[シグナル]の選択を解除します。
[コンポーネントプロパティ]ウィンドウの[ControlMode]を[RoutingRule]に変更します。
[RuleComponent]は、製品の流れるルートを変更する時、情報を参照する場所を変更できます。
[RuleComponent]をConveyorに変更します。
[RoutingRule]を展開します。
[環状ルール]を削除します。
[タイプ]から[ブール型表ルール]を選択します。
変数名を定義するため、[既定]タブにある[ShowSupport]を[変数]に設定します。
本動画では[ShowSupport]を使用して説明していますが、[ShowSupport]とは異なるプロパティを作成し、使用することも可能です。
FalseをRightに変更します。
シミュレーションを実行します。
製品がLeftの方向へ流れることが分かります。
[コンポーネントプロパティ]ウィンドウの[ShowSupport]のチェックを外します。
製品がRightの方向へ流れることが分かります。
シミュレーションをリセットし、[コンポーネントプロパティ]ウィンドウの[RuleComponent]を[Product]に変更します。
シミュレーションを実行します。
[RuleComponent]が[Product]であるため、[ブール型表ルール]は、製品のプロパティ[ShowSupport]を参照します。
しかし、製品にはプロパティ[ShowSupport]が存在せず、製品がコンベア上を流れません。
製品の情報を参照し、ルートを変更します。
シミュレーションをリセットします。
[Crossing Conveyor]を選択し、[RoutingRule]の[変数]を「boolean」に変更します。
[プロセス]タブを開き[エディタ]グループの[製品]を選択します。
[製品タイプエディタ]の[VC_Cylinder]を展開します。
[コンポーネントプロパティ]を選択し、右クリックでメニューを開きます。
[コンポーネントプロパティを追加]から[新規プロパティ]を選択することで、プロパティを追加できます。
[プロパティ]ウィンドウで、名前を[boolean]に変更します。
[Type]を[Boolean]に変更します。
シミュレーションを実行します。
FalseのためRightの方向へ製品が流れます。
[プロパティ]ウィンドウの[boolean]にチェックを入れ、Trueにします。
値をTrueに変更してから生成された製品よりTrueが適応され、Leftの方向へ製品が流れます。
シミュレーションをリセットします。
[Advanced]タブを選択します。
[SegmentSize]は、流れてくる製品と製品の間隔を変更できます。
[StructureWeight]は、支柱の幅を変更できます。
[RollerRadius]は、ロールの直径、[RollerSpacing]は、ロールの間隔を変更できます。
[NumberOfBelts]は、ベルトの個数を変更できます。
[BeltSpacing]は、[NumberOfBelts]で設定したベルトの間隔を変更できます。
[NumberOfBelts]、[BeltSpacing]は、[BeltRollers]にチェックをつけることで、有効になります。
[NumberOfSupports]は、支柱の本数を変更でき、入力された値×2の本数が3Dワールドに表示されます。
[SupportOffSet]は、支柱とCrossing Conveyorの端の距離を変更できます。
[ConveyorStartOffset]は、[Front]、[ConveyorEndOffset]は、[Back]と接続するConveyorとの距離を変更できます。
[Accumulate]は、製品がConveyorから流れず停滞した場合、製品が流れ終わるまでConveyorを停止させます。
[SpaceUtilization]は、製品がConveyorから流れず停滞した場合、製品を重複させます。
[RetainOffset]は、Conveyor上にランダムに配置された製品の位置をルートの開始位置へ移動できます。
[SingleLeg]は、支柱の本数を変更できます。
[ExtraAxle]は、ロールの軸の表示、非表示を変更できます。
[ProfileConstruction]は、見た目を変更できます。
[Materials]タブを選択します。
[Materials]タブでは、各パーツの色を変更できます。
[BeltMaterial]は、接続先のベルトの色を変更します。
[Crossing Conveyor]についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

CSVファイルをプロセスに反映しよう(1/3)

パイソンスクリプト（Python）を使用して、CSVファイルのデータからコンポーネントを指定し、ディレイステートメントで待機する時間を変更する方法
https://youtu.be/_L-_EVas9Os
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_177_p1.zip

CSVファイルのデータを、プロセスに反映する方法について説明します。
本動画では、CSVファイルのデータを元にコンポーネントを指定し、ディレイステートメントで待機する時間を変更します。
付属ファイル「ProcessChange1_before.vcmx」を開きます。
[プロセス]タブを開きます。
[エディタ]グループの[プロセス]を選択し、プロセスノードで行う作業内容を設定できます。
[ManualProcess]を選択し、作業内容を確認します。
TransportInで製品を搬入後、Delayで5秒間待機しています。
待機後、TransportOutで製品を搬出しています。
PythonScriptで、CSVファイルを読み込み、プロセスの設定を変更します。
CSVファイルを確認します。
付属ファイル「Delay.csv」を開きます。
1行目に、各列の項目名、2行目に各項目の値を記載しています。
1列目は、ディレイステートメントが設定されているコンポーネントの名前、2列目は待機時間です。
今回、文字コードにShift_JIS、区切り文字にカンマを使用しています。
CSVファイルを読み込むため、Geminiの画面に戻ります。
[モデリング]タブを開きます。
新しいコンポーネントを作成するため、[コンポーネント]グループの[新規]を選択します。
3Dワールドで選択できるようにするため、[ジオメトリ]グループの[フィーチャ]から[ブロック]を追加します。
CSVファイルを指定するため、プロパティを追加します。
[プロパティ]グループの[プロパティ]を展開し、[ベーシック]から[Uri]を選択します。
URIプロパティは、参照するファイルの名前と場所を定義できます。
[コンポーネントグラフ]ウィンドウに、[URI_1]が追加されたことがわかります。
[プロパティ]ウィンドウの[値]-[...]を選択することで、任意のファイルを指定できます。
「Delay.csv」を選択し、[開く]をクリックします。
ディレイステートメントの設定を変更するきっかけを、ボタンを押すこととします。
[プロパティ]グループの[プロパティ]を展開し、[ベーシック]から[ボタン]を選択します。
[コンポーネントグラフ]ウィンドウに、[Button_1]が追加されたことがわかります。
CSVファイルを読み込み、ディレイステートメントの設定を変更するため、PythonScriptを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
Pythonスクリプトエディタが自動的に開きます。
デフォルトで記述されているソースコードを、1行目以外削除します。
PythonScriptを含むコンポーネントの情報を取得するため、comp = getComponent()と記述します。
button = comp.getPropertyと記述することで、コンポーネントのプロパティを取得できます。
カッコ内にButton_1と記述し、名前が一致するプロパティを参照します。
プロセスにアクセスするために、Geminiのアプリケーションを参照する必要があります。
app = getApplication()と記述します。
CSVファイルを読み込む関数を作成するため、def ReadCSV(uri_prop_name):と記述します。
変数uri_prop_nameは、URIプロパティの名前です。
PythonScriptには、スニペットと呼ばれるプログラムの定型文があります。
CSV読み込みの詳細については、FAサイトの使用方法解説動画「CSVファイルを読み書きしよう」を参照してください。
[スニペット]から「_CsvRead」を選択します。
import csvを切り取り、from vcScript importの下に貼り付けます。
変数uriに、指定したファイルを代入するため、「＝」の後をcomp.getProperty(uri_prop_name).Valueに変更します。
冒頭の文字を削除することで、ファイルの場所を示すパスに変更します。
日本語を含むパスを、検索可能にするため、UTF-8形式に変換します。
strURI = unicode(uri[8:])と記述することで、変換できます。
CSVファイルのデータを配列に格納するため、list = []と記述し、空の配列を用意します。
with open(uri) as csv_file:で、指定したCSVファイルを開くことができます。
変換したパスを使用するため、カッコ内をstrURIに変更します。
現在、for文以下の記述で、カンマで区切られたデータごとに[出力]ウィンドウに表示しています。
カンマで区切られたデータを、順次、配列に追加するため、print rowを削除し、list.append(row)に変更します。
関数を実行した時、配列listを返すため、shiftキーとtabキーを2回押し、段落を2つ下げ、return listと記述します。
プロセスを取得する関数を作成するため、def GetProcess(name):と記述します。
変数nameは、CSVファイルにあるコンポーネントの名前です。
comp2 = app.findComponent()と記述することで、コンポーネントを指定できます。
カッコ内にstr(name)と記述し、CSVファイルのデータを文字列に変換し、名前が一致するコンポーネントを参照します。
指定したコンポーネントの、プロセスを制御しているプロセスエグゼキューターを参照するため、exe = comp2.findBehavioursByType(VC_PROCESSEXECUTOR)と記述します。
リストの0番目のみ取得するため、[0]と記述します。
プロセスエグゼキューターの持つプロセスを取得するため、process =exe.Processesと記述します。
リストの0番目のみ取得するため、[0]と記述します。
複数のプロセスを設定している場合は、[]内の数字で指定してください。
関数を実行した時、変数processを返すため、return processと記述します。
ディレイステートメントの設定を変更する関数を作成するため、def ChangeDelay(statement,time):と記述します。
変数statementは、ディレイステートメント、変数timeは、CSVファイルにある時間です。
statement.Distribution = timeと記述することで、ディレイステートメントの[分布]に変数timeの値を代入できます。
CSVファイルを読み込み、ディレイステートメントの待機時間を変更する関数を作成します。
def Import(arg):と記述します。
変数argはボタンプロパティの値ですが、今回は使用しません。
関数ReadCSVにURIプロパティの名前を渡し、変数dataに戻り値を代入するため、data = ReadCSV("URI_1")と記述します。
変数dataには、CSVファイル内の情報が入ります。
CSVファイルの2行目から順番に処理を実行します。
PythonScriptは、配列の番地が0から始まるため、2行目からの場合、for row in data[1:]:と記述します。
関数GetProcessに、CSVファイル1列目のコンポーネントの名前を渡し、変数proに戻り値を代入するため、pro = GetProcess(row[0])と記述します。
statements = pro.Statementsと記述することで、プロセスのステートメント一覧を取得できます。
ステートメント一覧からディレイステートメントを参照するため、for s in statements:と記述し、ステートメントを1つずつ確認します。
if s.Type == VC_STATEMENT_PROCESSDELAY:と記述し、ステートメントのタイプがディレイの場合、以下のプログラムを実行します。
関数ChangeDelayに、ディレイステートメントと、CSVファイルの2列目のデータを渡し、待機時間を変更します。
時間を変更する場合、CSVファイルのデータを数値に変換する必要があります。
ChangeDelay(s,float(row[1]))と記述します。
関数ChangeDelayの処理が完了した時、ループ処理を途中で終了するため、breakと記述します。
段落を4つ下げ、ボタンを押した時、関数Importを実行するため、button.OnChanged = Importと記述します。
呼び出される関数が、呼び出す位置より下にある場合、実行できないため注意が必要です。
[コンパイル]を選択します。
[コンポーネントプロパティ]ウィンドウのButton_1を押します。
[プロセス]タブを開き、Manual Workstationのディレイステートメントを確認します。
待機時間が10秒に変化していることがわかります。
CSVファイルのデータを元にコンポーネントを指定し、ディレイステートメントで待機する時間を変更する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

CSVファイルをプロセスに反映しよう(2/3)

パイソンスクリプト（Python）を使用して、CSVファイルのデータからコンポーネントを指定し、ステートメントを追加する方法
https://youtu.be/goEMcYhgFEw
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_177_p2.zip

CSVファイルのデータを、プロセスに反映する方法について説明します。
本動画では、CSVファイルのデータを元にコンポーネントを指定し、ステートメントを追加します。
付属ファイル「ProcessChange2_before.vcmx」を開きます。
[プロセス]タブを開きます。
[エディタ]グループの[プロセス]を選択し、[ManualProcess]の作業内容を確認します。
2カ所の[ManualProcess]に[TransportIn]を追加します。
PythonScriptで、CSVファイルを読み込み、ステートメントを追加します。
CSVファイルを確認します。
付属ファイル「TransportIn.csv」を開きます。
1行目に、各列の項目名、2行目以降に各項目の値を記載しています。
1列目は、ステートメントを追加するコンポーネントの名前です。
2列目はパート3で追加する製品タイプです。
今回は、1列目のコンポーネントの名前と個数を読み込み、ステートメントを追加します。
CSVファイルを読み込むため、Geminiの画面に戻ります。
[モデリング]タブを開きます。
パート1で作成したPythonScript用のコンポーネントを選択します。
[コンポーネントグラフ]ウィンドウの[+]アイコンを選択し、コンポーネントの階層構造を展開します。
[URI_1]を選択し、[プロパティ]ウィンドウの[値]-[...]をクリックします。
「TransportIn.csv」を選択し、[開く]をクリックします。
ステートメントを追加するきっかけを、ボタンを押すこととします。
パート1で作成した「Button_1」を使用します。
CSVファイルを読み込み、ステートメントを追加します。
ディレイステートメントの設定を変更するPythonScriptを参考にするため、パート1で作成したPythonScriptを開きます。
CSVファイルが指定のパスにあるか確認する必要があるため、import csvに、os,sysを追記します。
配列の要素となるCSVファイルのデータをカウントする必要があるため、import csvの下にimport collectionsと記述します。
CSVファイルを読み込めない場合、[出力]ウィンドウにメッセージを表記できるようにします。
CSVファイルのデータを格納するコードの下に、if False == os.path.exists(strURI):と記述します。
print "CSVファイルが見つかりません"と記述することで、CSVファイルが読み込めない場合、[出力]ウィンドウから確認できます。
見つからなかった場合、プログラムを終了するため、sys.exit()と記述します。
トランスポートインステートメントを指定のコンポーネントに追加するため、情報を取得します。
for row in data[1:]:から、breakまでを削除します。
コンポーネントの名前を基準にして配列を並べ替えるため、short = sorted(data,key = lambda x: x[0])と記述します。
column = len(short[0])と記述することで、CSVファイルの列数を取得できます。
print shortと記述し、並べ替えた結果を出力します。
[コンパイル]を選択します。
[コンポーネントプロパティ]ウィンドウのButton_1を押します。
[出力]ウィンドウに「Manual Workstation」、「Manual Workstation #2」、項目名の順に並んでいることが分かります。
PythonScriptに戻ります。
2次元配列では行数をカウントすることが困難なため、1次元配列に変換します。
first = sum()と記述します。
カッコ内にshort[:len(short) - column + 1],[]と記述することで、項目名を除外できます。
コンポーネントの名前のみの配列を作成するため、comp_list = first[::column]と記述します。
同じコンポーネントの名前がいくつあるか取得するため、num = collections.Counter(comp_list)と記述します。
collections.Counterは、配列の各要素をカウントできます。
各コンポーネントの名前と、個数の配列を作成するため、cname = num.items()と記述します。
num.items()は、リストの項目名とカウント回数です。
for i in cname:と記述し、コンポーネントごとにプロセスを確認します。
ステートメントを追加する関数を実行するため、CreateStatement()と記述します。
CreateStatementに必要な引数は、コンポーネントの名前、トランスポートインステートメントの追加個数です。
コンポーネントの名前と、追加個数は配列cnameに格納されているため、カッコ内にi[0]とi[1]と記述することで指定できます。
print i[0],"プロセスへの反映完了"と記述することで、プロセスへ反映されたことが[出力]ウィンドウから確認できます。
CSVファイルで指定している個数のみ、トランスポートインステートメントを作成する関数を作成します。
関数の名前をChangeDelayからCreateStatementに変更します。
カッコ内はステートメントを作成するために必要な引数name,valueに変更します。
関数CreateStatement内の記述を削除します。
トランスポートインステートメントの個数の初期値を定義するため、count_up = 0と記述します。
プロセス内にあったトランスポートインステートメントの、1つ目の行数を出力するため、変数trans_fを定義します。
trans_f = -1と記述します。
1行目は0、2行目は1、と、0始まりで出力します。
trans_fの初期値を-1としておくことで、trans_fが-1の場合はまだトランスポートインステートメントの1つ目を見つけていない、-1以外の場合はトランスポートインステートメントの1つ目を見つけていると、判別できます。
関数GetProcessに、CSVファイル1列目のコンポーネントの名前を渡し、変数proに戻り値を代入するため、pro = GetProcess(name)と記述します。
states = pro.Statementsと記述することで、プロセスのステートメント一覧を取得できます。
ステートメント一覧からトランスポートインステートメントを参照するため、for s in states:と記述し、ステートメントを1つずつ確認します。
if s.Type == VC_STATEMENT_TRANSPORTIN:と記述し、ステートメントのタイプがトランスポートインの場合、以下のプログラムを実行します。
if trans_f == -1:と記述し、1回目にトランスポートインステートメントを発見したときのみ、以下のプログラムを実行します。
trans_f = states.index(s)と記述し、トランスポートインステートメントの1つ目が、何行目にあるか取得します。
プロセスにCSVで指定した個数を追加するため、トランスポートインステートメントを全て削除します。
pro.deleteStatement(s)と記述します。
print trans_fと記述することで、トランスポートインステートメントを追加する場所を表示できます。
while count_up < value:と記述し、作成予定個数valueより、現在のトランスポートインステートメントの個数count_upが小さい間以下の処理を実行します。
トランスポートインステートメントを追加するため、trans = pro.addStatement(VC_STATEMENT_TRANSPORTIN,trans_f)と記述します。
ステートメントの定数名を参照するため、[ヘルプ]タブを開きます。
[パイソンAPI]を選択することで、PythonScriptに関するヘルプファイルを表示できます。
[定数]-[ステートメント定数]から確認できます。
トランスポートインステートメントの個数をカウントアップするため、count_up += 1と記述します。
[コンパイル]を選択します。
[コンポーネントプロパティ]ウィンドウのButton_1を押します。
[プロセス]タブを開き、[ManualProcess]のトランスポートインステートメントを確認します。
CSVファイルで指定しているコンポーネントの名前の個数、トランスポートインステートメントが追加されていることが分かります。
パート3では、今回追加したトランスポートインステートメントに製品タイプを設定します。
CSVファイルのデータを元にコンポーネントを指定し、ステートメントを追加する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

CSVファイルをプロセスに反映しよう(3/3)

パイソンスクリプト（Python）を使用して、CSVファイルのデータからトランスポートインステートメントに製品フィルターの製品タイプを設定する方法
https://youtu.be/_VY4U_TjlYw
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_177_p3.zip

CSVファイルのデータを、プロセスに反映する方法について説明します。
本動画では、パート2で追加したトランスポートインステートメントに製品フィルターの製品タイプを設定します。
本動画は、トランスポートインステートメントが追加されたファイル「ProcessChange2_after.vcmx」が必要です。
[プロセス]タブを開きます。
[エディタ]グループの[プロセス]を選択し、[ManualProcess]の作業内容を確認します。
TransportInは、製品フィルターを使用することで、搬入する製品を限定できます。
PythonScriptで、CSVファイルを読み込み、プロセスの設定を変更します。
CSVファイルを確認します。
付属ファイル「TransportIn.csv」を開きます。
1行目に、各列の項目名、2行目以降に各項目の値を記載しています。
1列目は、トランスポートインステートメントが設定されているコンポーネントの名前、2列目は搬入する製品タイプです。
複数の製品タイプに対して、製品タイプごとに製品を1つずつトランスポートインしたいため、トランスポートインステートメントごとに指定する製品タイプを、各行に記載しています。
同じコンポーネントに複数のトランスポートインを連続して設定する場合、CSVファイルの連続した行に、上から順に記載してください。
CSVファイルを読み込むため、Geminiの画面に戻ります。
[モデリング]タブを開きます。
パート1で作成したPythonScript用のコンポーネントを選択します。
[コンポーネントグラフ]ウィンドウの[+]アイコンを選択し、コンポーネントの階層構造を展開します。
[URI_1]を選択し、[プロパティ]ウィンドウの[値]-[...]をクリックします。
「TransportIn.csv」を選択し、[開く]をクリックします。
トランスポートインステートメントの設定を変更するきっかけを、ボタンを押すこととします。
パート1で作成した「Button_1」を使用します。
CSVファイルを読み込み、トランスポートインステートメントの設定を変更します。
トランスポートインステートメントを追加したPythonScriptを参考にするため、パート2で作成したPythonScriptを開きます。
製品タイプを取得するため、製品タイプを管理しているProductTypeManagerを参照します。
ProductTypeManagerを参照する順序を確認するため、ヘルプファイルを開きます。
[vcProductTypeManager]を選択します。
ProductTypeManagerは、「ProcessControllerに所有されている」とあるため、[vcProcessController]を選択します。
ProcessControllerは、「Simulationからアクセスできる」とあるため、シミュレーションを取得します。
sim = getSimulation()と記述することで、シミュレーションを取得できます。
mgr = sim.ProcessControllerと記述し、ProcessControllerを取得します。
「.ProductTypeManager」と追記し、ProductTypeManagerを参照します。
関数Importに製品タイプの情報も取得できるようにします。
コンポーネントの名前のみの配列を作成したコードの下に、prod_list = first[1::column]と記述することで、製品タイプのみの配列も作成できます。
現在設定中のコンポーネントが、並べ替えた配列の何番目から始まっているか取得します。
コンポーネントごとに、プロセスを確認しているコードの下に、ind = comp_list.index(i[0])と記述します。
関数CreateStatementは、1コンポーネントに対し1回実行します。
1コンポーネント分の製品タイプを一括で送信するため、配列を使用します。
第3引数に、prod_list[ind:ind+i[1]]と追記します。
トランスポートインステートメントの製品タイプを限定する関数を作成します。
def ChangeTransportIn(statement,type):と記述します。
トランスポートインステートメントからすべての製品フィルターの親オブジェクトを取得するため、fil = statement.Filterと記述します。
製品フィルターが1つも存在しない場合、新しい製品フィルターを作成します。
if fil.Type == VC_FILTER_ACCEPTALL:と記述することで、製品フィルターが存在しない場合、プログラムを実行できます。
製品フィルターの定数名はヘルプファイルを開き、[定数]-[ProductFilterType列挙]から確認できます。
fil = statement.setFilter()と記述することで、新しい製品フィルターを作成できます。
カッコ内に、VC_FILTER_CONFIGURABLEPRODUCTTYPEと記述し、製品タイプを限定します。
Geminiに設定されている製品タイプのリストから、CSVファイルのデータと一致する製品タイプを取得します。
pt = mgr.findProductType()と記述することで、ProductTypeManagerから製品タイプを参照できます。
カッコ内にstr(type)と記述し、名前が一致する製品タイプを参照します。
製品フィルターに製品タイプを設定します。
fil.AcceptedProductTypesProperty.Valueと記述し、有効な製品タイプの一覧を参照します。
CSVファイルのデータと一致した製品タイプを一覧に上書きするため、「=[pt]」と追記します。
「pt,pp」とカンマ区切りで記述することで、一つの製品フィルターに複数のタイプを設定することもできます。
製品タイプのリストを追加するため、関数CreateStatementの引数に、prodを追記します。
1つのプロセスに追加する製品タイプ配列の末尾の番地を定義します。
count_down = value-1と記述します。
addStatementで、指定した行数に新しいステートメントを追加すると、その行にあった既存のステートメントは下の行にずれます。
trans_fが0の場合、新しいトランスポートインステートメントの1つ目を1行目に追加後、2つ目を1行目に追加すると、1つ目は2行目にずれます。
追加した順番が早いほど、下の行になります。
CSVファイルで指定した製品タイプの順番に設定するには、逆の順番で、ChangeTransportInの製品タイプを指定する必要があります。
トランスポートインステートメントの製品タイプを限定する関数を実行するため、ChangeTransportIn(trans,prod[count_down])と記述します。
製品タイプ配列の番地をカウントダウンするため、count_down -= 1と記述します。
[コンパイル]を選択します。
[コンポーネントプロパティ]ウィンドウのButton_1を押します。
[プロセス]タブを開き、[ManualProcess]のトランスポートインステートメントを確認します。
CSVファイルで読み込んだ特定の製品タイプが、トランスポートインステートメントに設定されています。
トランスポートインステートメントに製品フィルターの製品タイプを設定する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

Geminiをインストールして操作してみよう

MELSOFT Geminiをインストールする方法と基本操作
（関連動画：インストール方法と基本操作説明）
https://youtu.be/kbobWH6CCKw

本動画では、MELSOFT Geminiをインストールする方法と基本操作について説明します。
まず初めに、Geminiのインストール方法について説明します。
FAサイトのダウンロードページからインストーラをダウンロードします。
ダウンロード後に、解凍したGeminiのインストーラであるGeminiSetup.exeをダブルクリックします。
インストーラが起動したら、内容を確認し、"次へ"をクリックします。
ライセンス許諾書が表示されます。
内容を確認したら、"同意する"をクリックします。
インストール先を指定し、"インストール"をクリックします。
"ショートカットの作成とファイルの関連付け"の内容を確認し、チェックをいれ"次へ"をクリックします。
インストールが完了したら"完了"をクリックします。
Geminiのインストール方法の説明は、以上になります。
次に、Geminiのライセンス認証について説明します。
Geminiのアイコンをダブルクリックして起動します。
Geminiのアクティベーションガイドが表示されるので、"次へ"をクリックします。
ライセンスには、スタンドアローンライセンスとネットワークライセンスの2種類があります。
スタンドアローンライセンスは、ライセンスを、使用するパソコンのローカルで管理します。
このライセンスを使用するには、製品キーが必要になります。
ネットワークライセンスは、ライセンスを、使用するパソコンではなくサーバで管理します。
使用するには、サーバのホスト名かIPアドレスとポート番号が必要になります。
今回は、スタンドアローンライセンスを使用します。
"製品キー"を入力し、"次へ"をクリックします。
ライセンスの設定を行い"完了"をクリックすると、自動的にGeminiが起動します。
ライセンス認証の説明は以上になります。
Geminiの画面インターフェースについて説明します。
画面上部は[メニュー]選択すると、ツールやコマンドが使用できます。
画面左側は[eカタログ]ウィンドウです。
Geminiの3Dワールド上に配置できるコンポーネントを管理しています。
[セルグラフ]ウィンドウは、現在配置されているコンポーネントをリストで表示します。
[プロパティ]ウィンドウは、選択しているコンポーネントのプロパティを変更できます。
画面中央は"3Dワールド"ウィンドウです。
ここにコンポーネントを配置して、レイアウトを構築します。
"3Dワールド"ウィンドウ上部にあるのは、"シミュレーションコントロール"です。
シミュレーションの再生や停止、リセットや再生速度の変更などができます。
"3Dワールド"ウィンドウ左上に表示されているのは浮動原点です。
3Dワールド上の視点を示しています。
"3Dワールド"ウィンドウ左側に表示されているのは、"3Dワールドツールバー"です。
コンポーネントの表示方法などを変更できます。
"3Dワールド"ウィンドウ左下に表示されているのは、"ビューセレクタ"です。
視点の切り替えができます。
"3Dワールド"ウィンドウ下部の[出力]ウィンドウは、コマンドの実行結果などのメッセージを表示します。
もし、ここで紹介したウィンドウが表示されていない場合は、[メニュー]-[ホーム]タブ-[ウィンドウ]-[表示]をクリックしてチェックがついているかを確認してください。
"3Dワールド"ウィンドウ上をクリアしたい時は、[ファイル]タブをクリックし、"全て消去"を選択すると、"3Dワールド"ウィンドウ上のコンポーネントが全て消去されます。
Ctrl+Nキーをクリックしても、同様に全てクリアできます。
[eカタログ]について説明します。
[eカタログ]には、"3Dワールド"に配置できるコンポーネントのファイルが保存されています。
コンポーネントのファイルは、[タイプ別モデル]と"製造者別モデル"の2つの分類方法で分類されます。
[タイプ別モデル]は、まずコンポーネントをタイプ別に分類し、その後タイプ別の中で製造者別に分類します。
"製造者別モデル"は、まずコンポーネントを製造者別に分類し、その後製造者別の中でタイプ別に分類します。
eカタログからコンポーネントを3Dワールドへ配置する操作について説明します。
eカタログに登録されているコンポーネントは、ダブルクリックをするか、3Dワールド上へドラッグ&ドロップすることで配置ができます。
ダブルクリックした場合は、原則3Dワールドの原点に配置されます。
ドラッグした場合は、ドロップした位置に配置されます。
また、[eカタログ]-[公開のモデル]-[Layouts]に登録されているコンポーネントは、先述のどちらの方法でも3Dワールドの原点に配置されます。
3Dワールドの原点には、フレームが表示されています。
表示されていない場合は、[ファイル]-[オプション]-[ディスプレイ]にある[ワールド原点フレーム]にチェックを入れると表示されるようになります。
レイアウトを使用して基本操作について説明します。
[eカタログ]ウィンドウ-[公開のモデル]-[Layouts]から「Machine Tending」をダブルクリックして、3Dワールド上に配置します。
3Dワールド上のマウス操作について説明します。
マウスのスクロールをホイールすることで、視点を近づけたり遠ざけたりすることができます。
右クリックをしながらマウスをドラッグすると、視点を切り替えることができます。
3Dワールド上のコンポーネントをクリックすると、そのコンポーネントを選択した状態になります。
「ホーム」タブ-「マニピュレーション」-「PnP」をクリックした状態で、選択した状態のコンポーネントをドラッグすると、選択しているコンポーネントの位置を移動できます。
また、この状態で右クリックすると、そのコンポーネントを対象に様々な操作ができます。
マウス操作の説明は以上になります。
[コンポーネントプロパティ]ウィンドウについて説明します。
3Dワールド上のコンポーネントを選択していると、右ウィンドウに[コンポーネントプロパティ]ウィンドウが表示されます。
このウィンドウでは、選択しているコンポーネントの設定ができます。
Ctrlキーをクリックしながら別のコンポーネントをクリックしコンポーネントを複数選択した状態にします。
この場合、共通するプロパティのみが[コンポーネントプロパティ]ウィンドウに表示されます。
[コンポーネントプロパティ]ウィンドウの説明は以上になります。
"3Dワールドツールバー"の各機能について説明します。
"全て"は、3Dワールド上に配置されている全てのコンポーネントが"3Dワールド"ウィンドウに表示されるように視点を切り替える機能です。
"選択を拡大"は、選択しているコンポーネントの全体像が見える位置へ視点を切り替える機能です。
"ヘッドライト"は、表面およびコンポーネントのジオメトリのエッジを強調するために、光の当て方を切り替える機能です。
"正射"は、3Dワールドのカメラの投影表示を正投影表示に切り替える機能です。
"レンダリングモード"は、3Dワールド上でコンポーネントの表示を切り替える機能です。
"フレームタイプ"は、3Dワールド上のフレームの表示を切り替える機能です。
"ポジションフレームディスプレイオプション"は、ロボットプログラムなどで設定するポジションフレームの表示を切り替える機能です。
"ビューエディタ"は、視点の保存/切り替えをする機能です。
＋アイコンで現在の視点をビューエディタに追加します。
"ビューエディタ"に追加された"Viewクリックすると、視点が移動します。
"View"のアップデートアイコンをクリックすると、現在の視点を"View"に保存します。
削除アイコンをクリックすると、"View"を削除します。
"3Dツールバー"の説明は以上になります。
次に、"ビューセレクタ"について説明します。
"ビューセレクタ"をクリックすると現在の視点を指定した方向や角度からの視点に変更します。
現在設定されているビューはハイライト表示されます。
ダウンビューからの視点に変更する場合、いずれかのビューをダブルクリックします。
トップビューをクリックするたびにカメラが90度回転します。
エッジをクリックすると、2つの側面からの視点に変更できます。
コーナーをクリックすると、3つの側面からの視点に変更できます。
"ビューセレクタ"の説明は、以上になります。
[マニピュレーション]について説明します。
[マニピュレーション]は、3Dワールド上のコンポーネントを操作する時に使用する機能です。
この設定は、[ホーム]タブの他にも[プロセス]タブ、[モデリング]タブ、[プログラム]タブに存在します。
今回は、[ホーム]タブの4つの機能について説明します。
[選択]は、3Dワールド上のコンポーネントを範囲選択で複数選択する機能です。
マウスをドラッグして四角形を表示し、その四角形に触れているコンポーネントを全て選択します。
また、白の三角マークをクリックすることで、選択の仕方を変更できます。
[移動]は、選択したコンポーネントを移動させる機能です。
コンポーネントを選択すると、矢印や四角形などが表示されます。
矢印や四角形をドラッグすると、選択しているコンポーネントを直線的に移動させることができます。
また、曲線をドラッグすることで、選択しているコンポーネントの角度を変更できます。
ピンクの丸は、コンポーネントの原点を示しており、矢印や四角形同様ドラッグすることでコンポーネントを移動できます。
加えて、原点をドラッグして別のコンポーネントに近づけた時、自動的に位置を調整します。
[PnP]は、選択したコンポーネントを移動させ、移動先の近くにある別のコンポーネントと接続する機能です。
接続できる向き・位置は、コンポーネントの黄色の三角マークの有無で判別できます。
接続できるコンポーネント同士を近づけた時に緑色の矢印が表示されます。
接続すると緑色の三角マークが表示されます。
[インタラクティブ]は、コンポーネントの動くことができるパーツを、その可動範囲内で動かす機能です。
3Dワールド上の「Process Machine – Pro Lathe」をクリックします。
扉やアームなどをドラッグすると、位置や角度が変更できます。
[マニピュレーション]の説明は、以上になります。
"シミュレーションコントロール"について説明します。
"シミュレーションコントロール"は、シミュレーションを操作する時に使用します。
"再生"をクリックすると、シミュレーションが再生されます。
シミュレーション再生中の"再生"ボタンは"一時停止"に変わり、クリックするとシミュレーションを停止します。
シミュレーションをリセットする時は"リセット"をクリックします。
シミュレーションの再生速度は、数値をクリックして値を変更する、またはその横のボリュームバーをドラッグして調整することで変更できます。
"シミュレーションコントロール"の説明は以上になります。
[エクスポート]について説明します。
[エクスポート]は、現在のレイアウトやシミュレーションの様子を、ファイル出力するモードです。
[エクスポート]には、[ジオメトリ]、[画像]、[ビデオ]、[PDF]の4つのモードがあります。
また、[シミュレーションコントロール]にも、[PDF]、[ビデオ]、[アニメーション]の3つのモードがあり、合計5つのモードがあります。
シミュレーション再生中の様子を録画したり、画像データとして保存したい時は、[エクスポート]の各コマンドをクリックします。
今回は、画像出力を行います。
[画像をエクスポート]ウィンドウで各設定を行い、"エクスポート"をクリックし、ファイル名と保存先を指定して、"保存"をクリックします。
画像ファイルが出力されました。
[エクスポート]についての説明は以上になります。
[図面]タブについて説明します。
[図面]タブは、3Dワールドのレイアウトを線や点などの2Dの図面で表現する機能です。
[図面]タブをクリックします。
現在の3Dワールドのレイアウトが2Dの図面で表示されます。
現在の画面を消去します。
[図面]-[消去]をクリックすると、表示中の図面が削除されます。
図面を作成します。
[図面]-[テンプレートをロード]をクリックします。
[テンプレートをロード]は、テンプレートファイルを読み込むことができる機能です。
[テンプレートインポート]ウィンドウから"テンプレート"で任意のファイルを選択し、[インポート]をクリックします。
テンプレートを読み込みます。
[ビューをクリエイト]は、3Dワールドのレイアウトから図面を作成するコマンドです。
視点を決めて、図面を作成します。
今回は上から見た図面を作成します。
[ビューをクリエイト]-[上部]をクリックします。
3Dワールドを上から見た時の図面を作成できました。
図面右下にタイトルや縮尺などが記載されています。
これらの記述は、図面をクリックし[コンポーネントプロパティ]ウィンドウから変更できます。
[BOM]タブは、部品表について設定するコマンドです。
[BOM]-[クリエイト]をクリックすると、図面に部品表が追加されます。
[BOM]-[削除]をクリックすると、部品表を削除できます。
[エクスポート]-[図面]をクリックすることで、図面をエクスポートできます。
[図面]タブの説明は、以上になります。
[統計情報]について説明します。
[統計情報]は、シミュレーション再生中に統計情報を取得してダッシュボードに表示できます。
[ホーム]タブ-[統計情報]をクリックします。
eカタログに登録されているレイアウトはあらかじめダッシュボードの設定がされています。
ダッシュボードを追加する場合は、"新規タブを追加"をクリックします。
"1列 1行標準ダッシュボード"を選択し"クリエイトをクリックすると、ダッシュボードが作成されます。
今回は例として、追加したダッシュボードに生成した製品の数を線グラフで表示します。
"ラインチャート"をクリックします。
画面右に[プロパティ]ウィンドウが表示され、グラフの設定ができます。
"コンポーネント"をクリックし、"Conveyor #3"を選択します。
[プロパティ]をクリックし、"Statistics.PartsEntered"を選択します。
シミュレーションを再生すると、ダッシュボードに統計情報が表示されるようになります。
[統計情報]-[間隔]を変更することで、統計情報を取得する間隔を変更できます。
取得した統計情報はエクスポートできます。
[統計情報]-[グラフをエクスポート]-[Excelにエクスポート]をクリックします。
ファイル名や保存先を設定して"保存"をクリックすると、統計情報をExcelファイルで出力します。
以上で、「Geminiをインストールして操作してみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

Gemini上のオブジェクトの見え方について学ぼう

背景色、グリッド線、レンダリングモードなどの表示設定を変更する方法
https://youtu.be/KZ10pjlSj6M
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_122.zip

本動画では、Gemini上でのオブジェクトの見え方についての設定である、フロアディスプレイオプションの設定と3Dワールドツールバーの使い方について説明します。
初めに、「Gemini上のオブジェクトの見え方について学ぼう.vcmx」を開きます。
フロアディスプレイオプションの設定について説明します。
[ファイル]-[オプション]-[ディスプレイ]から、3Dワールド上のフロアについての設定ができます。
"背景色"は、背景色を設定します。
"床面表示"は、床部分を表示するかしないかを設定します。
"グリッド表示"は、床のマス目を表示するかしないかを設定します。
"フロアの色"は、床の色を設定します。
"床面反射率"は、床の反射率を設定します。
"自動フロアリサイズ"は、オンの場合、3Dワールド上のコンポーネントの位置に基づいてフロアサイズを自動で設定します。
"フロアサイズ"は、"自動フロアリサイズ"がオフの場合、フロアサイズを手動で設定します。
"ワールド原点フレーム"は、オンの場合、3Dワールドの原点をフレームとして表示します。
これらの設定を行った場合、画面右下にあるOKボタンを押下することで、フロアディスプレイオプションの設定を反映させることができます。
また、変更した設定を反映させない場合は、キャンセルボタンを押下するか、左上の矢印ボタンを押下してください。
実際に設定を変更して、3Dワールド上のフロアを見てみましょう。
3Dワールドでグリッド線を表示させます。
"グリッド表示"の設定をオンにし、画面右下にあるOKボタンを押下します。
3Dワールドにグリッド線が表示されます。
床面反射率を設定します。
[ファイル]-[オプション]-[ディスプレイ]から、"床面反射率"の右側の数値が0.20になるようにスクロールバーを右にスライドさせます。
画面右下にあるOKボタンを押下します。
3Dワールドに存在するコンポーネントに光が当たったように床に反射します。
設定した"グリッド表示"と"床面反射率"を元に戻します。
[ファイル]-[オプション]-[ディスプレイ]から、"グリッド表示"の設定をオフにします。
"床面反射率"の右側の数値が0になるようにスクロールバーを左にスライドさせます。
画面右下にある"OK"ボタンを押下します。
これで、グリッド線と床面反射が無くなりました。
次に、"3Dワールドツールバー"の各機能について説明します。
"全て"は、現在の視点から、3Dワールド上の全てのコンポーネントが見える視点に移動する機能です。
3Dワールドの視点を変更したあと、カメラを中心に戻したい場合に"全て"アイコンをクリックします。
3Dワールドの視点が中心に戻されます。
もう一度3Dワールドの視点を変更します。
今度は、CtrlキーとFキーを押下します。
"全て"アイコンをクリックした際と同じ動作になります。
"選択を拡大"は、選択しているコンポーネントを拡大して映す位置に視点を移動する機能です。
コンポーネントが選択されていない状態でクリックした場合は、何も起こりません。
黒色のコンポーネントを選択し、"選択を拡大"アイコンをクリックすると、選択された黒色のコンポーネントが拡大され、画面の中心に表示されます。
複数選択の場合を確認します。
"全て"アイコンを押下し、3Dワールド上のコンポーネントを全て表示させます。
黒色のコンポーネントを選択し、Ctrlキーを押しながら赤色のコンポーネントを選択します。
"選択を拡大"アイコンを押下すると、複数選択したコンポーネントの中心が拡大され、画面の中心に表示されます。
再度Ctrlキーを押しながら赤色のコンポーネントを選択すると、赤色のコンポーネントの選択が外れます。
この状態で"選択を拡大"アイコンを押下すると、先ほど選択していた黒色のコンポーネントが拡大され、画面の中心に表示されます。
"ヘッドライト"は、現在の視点に向かって光を当てるようにする機能です。
この機能を有効にすると、コンポーネントをどの角度から見ても光が当たるため、鮮明に確認できます。
"正射"は、3Dワールドでの正投影表示のオン/オフの設定を行います。
正投影とは、立体的に表示されているものを平面的に表示するための手法の1つで、ものの形状や高さ/幅/奥行きを正確に表すことができます。
任意の「Block Geo」を選択し、[マニピュレーション]-[移動]が選択された状態でドラッグをして移動させます。
画面では上に移動させましたが、移動させたことで他のブロックに比べ小さく見えるようになりました。
"3Dワールドツールバー"の"正射"をクリックします。
今移動したブロックが、移動していないブロックと同じ大きさに見えるようになりました。
"レンダリングモード"は、3Dワールドにおいて、コンポーネントの線や物質の表面、エッジなどがどのように視覚化されるかに影響します。
CtrlキーとNキーを押下し、現在のレイアウトを削除します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Layouts]から、"Machine Tending"をダブルクリックします。
"レンダリングモード"の設定で、3Dワールド上のレイアウトの表示が変わります。
レンダリングモードには、"ワイヤフレーム"、"全エッジをシェード"、"面エッジをシェード"、"X線シェード"、"シェード"、"マテリアルシェード"、"リアリスティックシェード"、"リアリスティックエッジシェード"があります。
使用用途に合わせて変更できます。
また、この"レンダリングモード"は、[ホーム]タブ-[エクスポート]-[画像]から画像データとしてエクスポートする時にも設定します。
"フレームタイプ"は、3Dワールド上の各フレームの表示/非表示の設定を行います。
また、三角アイコンをクリックすることで、表示するフレームを選択できます。
表示するフレームには、"ロボットベース"、"ロボットツール"、"ロボットワールドフレーム"、"ロボットポジション"、"フレーム"があります。
使用用途に合わせて変更できます。
なお、"ロボットポジション"は[プログラム]タブで記述するロボットルーチンでのロボットの移動位置です。
"ポジションフレームディスプレイオプション"は、ロボットポジションフレームのラベルの表示/非表示を設定します。
以上で、「Gemini上のオブジェクトの見え方について学ぼう」を終わります。
ご視聴ありがとうございました。

=================================================================================

Lift Conveyorを使ってみよう

上下に動作するコンベア（Lift Conveyor）を使う方法と、複数製品をアタッチして同時に流す方法（Bundler Point、De-bundler）
https://youtu.be/H0rbtVIg1c4
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_169.zip

本動画では、[Lift Conveyor]について説明します。
本動画の内容には、MELSOFT Gemini Essentialsでは使用できない機能が含まれています。
ProfessionalまたはPremiumを使用してください。
付属ファイル「Lift Conveyor_before.vcmx」を開きます。
3Dワールドの[Lift Conveyor]を選択し、[コンポーネントプロパティ]ウィンドウを表示します。
[既定]タブの[Shuttle_joint]は、リフトの高さを変更できます。
シミュレーション開始前に高さを設定しておくと、その位置からシミュレーションを開始することも可能です。
[ShowPortNames]にチェックをつけることで、設定されているポートを表示できるためチェックをつけます。
ポートが表示されたことが分かります。
[SideA_PortPlaces]、[SideB_PortPlaces]は、製品を搬入・搬出するポートの位置を変更できます。
カンマ区切りでポートの高さを入力することで、ポートの個数を増やせます。
ポートの位置や個数を設定するため、[SideA_PortPlaces]、[SideB_PortPlaces]に「700,1400」と入力します。
ポートの位置や個数を変更した場合、更新する必要があります。
[UpdatePorts]を選択します。
3Dワールドにある[Lift Conveyor]の、AとBのポートの位置や個数が、変更されたことが分かります。
[UpdatePorts]で値を更新した場合、PnP接続が解除されるため、コンベアを再接続します。
[UnloadingDelay]は、次の製品を搬入するまでの待機時間を変更できます。
[ConveyorLength]、[Width]は、[Lift Conveyor]のサイズを変更できます。
[ConveyorSpeed]は、製品がコンベア上を流れる速度を変更できます。
[Presets]は、コンベアの種類を変更できます。
[AutoProperties]は、Conveyor等にPnP接続した際、接続した先のプロパティConveyorWidth等と、同じ値になります。
[ShowRollers]は、ロールの表示、非表示を変更できます。
[ShowBelts]は、ベルトの表示、非表示を変更できます。
[ShowGuideRails]は、ガイドレールの表示、非表示を変更できます。
[ShowSupport]は、支柱の表示、非表示を変更できます。
[ShowStartIdler]は、ロールの開始、[ShowEndIdler]は、ロールの終了位置の表示を変更できます。
[RoutingRule]についての詳細は、FAサイトの使用解説動画「製品ごとに輸送経路を変えてみよう」を参照ください。
[Servo]タブを選択します。
[ShuttleSpeed]は、リフトの上下する速度、[ShuttleAcc]は、加速度、[ShuttleDec]は、減速度を変更できます。
[AutoHoming]タブを選択します。
[Enabled]にチェックをつけることで、[AutoHoming]タブの設定内容を有効にできます。
設定内容を有効にするため、チェックをつけます。
[Delay]と[Position]は、[Delay]で設定した時間が経過すると、[Position]の位置に移動し待機します。
[Delay]に「3」、[Position]に「1000」と入力します。
シミュレーションを実行します。
[Delay]で設定した時間が経過すると、[Position]の位置に移動することが分かります。
シミュレーションをリセットします。
[Enabled]のチェックを外します。
[Advanced]タブを選択します。
[RetainOffset]、[RetainOrientation]は、Conveyorのルート以外に配置された製品の角度や位置を保持するかを変更できます。
[Accumulate]は、製品がConveyorから流れず停滞した場合、製品が流れ終わるまでConveyorを停止させるかを変更できます。
[SpaceUtilization]は、製品がConveyorから流れず停滞した場合、製品を隣接するかを変更できます。
[SegmentSize]は、流れてくる製品と製品の間隔を変更できます。
[Lift Conveyor]の最大積載量は1つのため、[Accumulate]、[SpaceUtilization]、[SegmentSize]は、使用しません。
[StructureWeight]は、支柱の幅を変更できます。
[RollerRadius]は、ロールの直径、[RollerSpacing]は、ロールの間隔を変更できます。
[BeltRollers]は、ベルト内部にあるローラーにNumberOfBelts、BeltSpacingを反映させることができます。
[NumberOfBelts]は、ベルトの個数を変更できます。
[BeltSpacing]は、[NumberOfBelts]で設定したベルトの間隔を変更できます。
[GuideRailHeight]は、ガイドレールの幅、[GuideRailHeightOffset]は、ガイドレールの高さ、[GuideRailWidthOffset]は、ガイドレールとガイドレールの距離を変更できます。
[NumberOfGirders]は、横方向、[NumberOfSupports]は、縦方向の支柱の本数を変更できます。
[SupportOffset]は、縦方向の支柱とLift Conveyorの端の距離を変更できます。
[SingleLeg]は、[Lift Conveyor]の支柱の本数は変更されませんが、[Lift Conveyor]に接続されたConveyorの支柱の本数を変更できます。
[ExtraAxle]は、ロールの軸の表示、非表示を変更できます。
[ProfileConstruction]は、支柱の表示を変更できます。
[ConveyorStartOffset]、[ConveyorEndOffset]は、コンベアの開始、終了位置と接続するConveyorとの距離を変更できます。
[Materials]タブを選択します。
[Materials]タブでは、各パーツの色を変更できます。
生成された製品を、3つまとめてLift Conveyorへ流れるように設定します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Conveyor Utilities]から、[Bundler Point]を3Dワールドにドラッグ＆ドロップします。
[Bundler Point]は、コンベア上を流れる製品をひとまとめにすることができます。
[Bundler Point]を左側にあるConveyorへ接続します。
[コンポーネントプロパティ]ウィンドウの[既定]タブにある[AttachPartsTo]は、どの製品にアタッチし搬送するかを変更できます。
最初に流れてくる製品にアタッチするため、[FirstPart]を選択します。
[StopFirst]は、同時に載せる製品が揃うまで搬送先直前で製品を停止できます。
製品が全て揃ってから[Lift Conveyor]に載せるため、[StopFirst]にチェックをつけます。
[BundleSize]は、同時に載せる個数を指定できます。
今回は、3つまとめて載せるため、デフォルトのまま使用します。
シミュレーションを実行します。
Bundler Point上で製品が停止し、指定した個数揃ってからLift Conveyorへ搬送されることが分かります。
1つ目に流れてきた製品に2つの製品がアタッチされ、1つの製品として搬送されます。
シミュレーションをリセットします。
アタッチされた製品を[Lift Conveyor]で搬送後、デタッチするように設定します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Conveyor Utilities]から、[De-bundler Point]を3Dワールドにドラッグ＆ドロップします。
[De-bundler Point]は、コンベア上を流れるアタッチされた製品をデタッチすることができます。
[De-bundler Point]を右側にあるConveyorへ接続します。
シミュレーションを実行します。
[Lift Conveyor]から搬送された製品が[De-bundler Point]を通過後、1つ目の製品から2つの製品がデタッチされていることが分かります。
シミュレーションをリセットします。
[Lift Conveyor]は、プロセスモデリングでも使用可能です。
プロセス、フローを設定することで[Lift Conveyor]も動作します。
[Feeder Process]等を直接接続すると、正常に動作しません。
必ず[Conveyor]等を間に挟んで接続します。
[Lift Conveyor]についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

アイドリングと充電の設定をしてみよう

AGVの一時待機と自動充電の設定方法
https://youtu.be/KTV7yVuE_Ks
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_086.zip

本動画では、AGVなどのアイドリングと充電についての設定方法について説明します。
まず初めに、「アイドリングと充電の設定をしてみよう.vcmx」を開きます。
このレイアウトに、充電場所とアイドリング時の待機場所を追加します。
まず、充電場所の設定を行います。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Resource Utilities]から"Charging Location"を3Dワールド上にドラッグ&ドロップします。
"Charging Location"は、AGVなどを制御するトランスポートコントローラとインターフェース接続して、充電場所として使用できるコンポーネントです。
配置した「Charging Location」と「Mobile Robot Transport Controller」をインターフェース接続します。
[ホーム]タブ-[接続]-[インターフェース]をクリックします。
[インターフェースに接続]ウィンドウから"コンポーネント"に"Charging Location"を選択すると、"このリストからインターフェースに接続"に"Mobile Robot Transport Controller"が表示されるので、それをクリックします。
3Dワールド上で「Mobile Robot Transport Controller」の"Idle/ChargingLocations"と"Charging Location"が接続されたことを確認し、[インターフェースに接続]ウィンドウを閉じます。
これで、充電場所の設定ができました。
充電などのバッテリーの設定は、コンポーネントプロパティで設定します。
「Mobile Robot Resource」をクリックし、[コンポーネントプロパティ]ウィンドウ-[Power]タブをクリックします。
[Power]タブには、「Mobile Robot Resource」のバッテリーの設定に関するプロパティが定義されています。
"Enable"は、バッテリーに関する設定を有効にするか設定します。
チェックがない場合、[Power]タブの設定が無効になり、シミュレーションを停止しない限り、「Mobile Robot Resource」が稼働し続けるようになります。
"Capacity"は、バッテリーの総容量の設定です。
"InitialCapacity"は、バッテリーの初期容量の設定です。
"BusyConsumption_h"は、「Mobile Robot Resource」が"Busy(稼働)"状態の時に消費される、1時間当たりのバッテリー消費量の設定です。
"IdleConsumption_h"は、「Mobile Robot Resource」が"Idle"状態の時に消費される、1時間当たりのバッテリー消費量の設定です。
"ReChargeRate_h"は、1時間当たりの充電量の設定です。
"ToChargeLimit"は、「Mobile Robot Resource」が充電場所に移動するようになるバッテリー残量の設定です。
"Capacity"を全体とした時の割合となる数字を設定します。
「Mobile Robot Resource」のバッテリー総容量に対するバッテリー残量の割合が"ToChargeLimit"を下回った場合、充電場所に移動し充電を開始します。
"ChargeUntilLimit"は、充電を終了するバッテリー残量の設定です。
"Capacity"を全体とした時の割合となる数字を設定します。
充電を行い、バッテリー総容量に対するバッテリー残量の割合が、"ChargeUntilLimit"以上になった時、充電を終了し、通常の作業へ戻ります。
"CurrentCapacity"は、現在のバッテリー残量の設定です。
この値は編集することはできません。
[Power]タブの設定を変更して、「Charging Location」の動作を確認します。
"BusyConsumption_h"を"1000"に変更します。
"ReChargeRate_h"を"500"に変更します。
シミュレーションを再生します。
「Mobile Robot Resource」のバッテリー残量が"ToChargeLimit"を下回った場合、「Charging Location」へ移動して充電します。
次に、アイドリング時の待機場所を追加します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Resource Utilities]から"Idle Location"を3Dワールド上にドラッグ&ドロップします。
"Idle Location"は、アイドリング時のリソースの待機場所として使用できるコンポーネントです。
使用するには、"Charging Location"と同様に、トランスポートコントローラとインターフェース接続する必要があります。
[ホーム]タブ-[接続]-[インターフェース]をクリックします。
[インターフェースに接続]ウィンドウから"コンポーネント"に"Idle Location"を選択すると、"このリストからインターフェースに接続"に"Mobile Robot Transport Controller"が表示されるので、それをクリックします。
3Dワールド上で「Mobile Robot Transport Controller」の"Idle/ChargingLocations"と「Idle Location」の"Idle Location"が接続されたことを確認し、[インターフェースに接続]ウィンドウを閉じます。
これで、アイドリング時の待機場所が設定できました。
アイドリング状態になるように設定を変更して、動作を確認します。
[プロセス]タブ-[エディタ]-[プロセス]をクリックし、"ManualProcess"をクリックします。
"Delay"をクリックし、[ステートメントプロパティ]ウィンドウから"分布"を"100"に変更します。
もう1つの"ManualProcess"も同様に変更します。
シミュレーションを再生します。
"ManualProcess"の"Delay"が実行され「Mobile Robot Resource」がアイドリング状態になると、"Idle Location"へ移動して待機します。
ここまでで、充電場所とアイドリング時の待機場所の設定ができました。
「Charging Location」はアイドリング時の待機場所とすることができます。
設定を変更して、動作を確認します。
「Charging Location」をクリックします。
[コンポーネントプロパティ]ウィンドウから"AllowIdling"にチェックを入れます。
[ホーム]タブ-[接続]-[インターフェース]をクリックします。
[インターフェースに接続]ウィンドウから"コンポーネント"を"Idle Location"に変更し、"このリストからインターフェースに接続"の"Mobile Robot Transport Controller"をクリックして接続を解除します。
[インターフェースに接続]ウィンドウを閉じて、シミュレーションを再生します。
アイドリング時に、「Charging Location」へ移動します。
「Idle Location」は、充電場所として使用できます。
設定を変更して動作を確認します。
「Idle Location」をクリックします。
[コンポーネントプロパティ]ウィンドウ-[既定]タブから"Charger"にチェックを入れます。
[ホーム]タブ-[接続]-[インターフェース]をクリックします。
[インターフェースに接続]ウィンドウから"コンポーネント"が"Idle Location"であることを確認し、"このリストからインターフェースに接続"の"Mobile Robot Transport Controller"をクリックして接続します。
"コンポーネント"を"Charging Location"に変更し、"このリストからインターフェースに接続"の"Mobile Robot Transport Controller"をクリックして接続を解除します。
[インターフェースに接続]ウィンドウを閉じます。
[プロセス]タブ-[エディタ]-[プロセス]をクリックし、"ManualProcess"をクリックします。
"Delay"をクリックし、[ステートメントプロパティ]ウィンドウから"分布"を"5"に変更します。
もう1つの"ManualProcess"も同様に変更します。
シミュレーションを再生します。
「Mobile Robot Resource」のバッテリー残量が"ToChargeLimit"を下回った時、「Idle Location」へ移動して充電します。
以上で、「アイドリングと充電の設定をしてみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

アセンブリ機能を使ってみよう

アセンブリ機能を使って、シミュレーション中に製品の組立や分解をする方法
https://youtu.be/0VKpT91D2qc
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_049.zip

本動画では、アセンブリを使って、シミュレーション中に製品を組み立て、分解する方法について説明します。
アセンブリの定義方法についての詳細は「組み立てや分解ができる製品を定義しよう」を参照ください。
アセンブリの定義には、製品タイプエディタに登録されているパーツを使用します。
そのため、パーツを製品タイプエディタに追加します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Products and Containers]から"Parametric Pallet with Collar"、"Cube"、"Lathe Comp 1"、"Lathe Comp 2"を3Dワールド上にドラッグ&ドロップします。
「Cube」を左クリックして、[コンポーネントプロパティ]ウィンドウ-[既定]タブから、"CubeLength"を"400"、"CubeWidth"を"150"、"CubeHeigth"を"400"に変更します。
[プロセス]タブ-[エディタ]-[製品]をクリックします。
[製品タイプエディタ]ウィンドウ-[製品の定義]-[フローグループを追加]を2回クリックします。
今回は、パレットの上に各パーツを配置するアセンブリを定義します。
パレットの上に配置するパーツの定義を"Parts"、パレットとアセンブリの定義を"Pallets"に分けて設定します。
"フローグループ番号1"の"名称"を"Parts"、"フローグループ番号2"の"名称"を"Pallets"に変更します。
製品タイプを追加して、先ほど配置したコンポーネントを割り当てます。
"Parts"に、「Parametric Pallet with Collar」以外のパーツを定義します。
[製品タイプエディタ]ウィンドウ-"Parts"を選択した状態で、"製品の定義"-"製品タイプを追加"を3回クリックします。
"製品タイプ番号1"をクリックします。
[Name]を"Box"に変更し、"Pick Component from 3D world"をクリックして3Dワールド上の"Cube"を選択します。
"製品タイプ番号2"をクリックします。
[Name]を"Cylinder"に変更し、"Pick Component from 3D world"をクリックして3Dワールド上の「Lathe Comp 1」を選択します。
"製品タイプ番号3"をクリックします。
[Name]を"Cap"に変更し、"Pick Component from 3D world"をクリックして3Dワールド上の「Lathe Comp 2」を選択します。
[製品タイプエディタ]ウィンドウ-"Pallets"を選択した状態で"製品タイプを追加"をクリックします。
"製品タイプ番号1"をクリックします。
[Name]を"Pallet"に変更し、"Pick Component from 3D world"をクリックして3Dワールド上の「Parametric Pallet with Collar」を選択します。
これで、アセンブリの定義に使用するパーツを製品タイプエディタに追加できました。
次に、製品タイプエディタに"アセンブリ"を追加して、アセンブリを定義します。
[製品タイプエディタ]ウィンドウ-"Pallets"を選択した状態で、"製品の定義"-"アセンブリを追加"をクリックします。
"アセンブリ番号1"を選択して[名前]を"FullPallet"に変更します。
"FullPallet"を展開して、"ステップ番号1"を選択します。
[名前]を"PalletStep"に変更します。
"Box"と"Cylinder"のアセンブリステップを定義します。
"PalletStep"を右クリックして、"ステップを追加"を2回クリックします。
追加した"ステップ番号1"の[名前]を"BoxesStep"、"ステップ番号2"の[名前]を"CylindersStep"に変更します。
"Cap"を配置するアセンブリステップは、"CylindersStep"の子ステップになるように定義します。
"CylindersStep"を右クリックして、"ステップを追加"をクリックします。
追加した"ステップ番号1"の[名前]を"CapsStep"に変更します。
各アセンブリステップのアセンブリスロットにパーツを割り当てます。
"PalletStep"を選択して、"アセンブリエディタを開く"をクリックします。
「PalletStep-アセンブリスロット」を選択します。
[プロパティ]ウィンドウから"既定の製品タイプ"を"Pallet"に変更します。
次に、"BoxesStep"をクリックします。
「BoxesStep-アセンブリスロット」を選択し、[プロパティ]ウィンドウから"既定の製品タイプ"を"Box"に変更します。
アセンブリスロット1つにつき、割り当てるパーツは1つだけです。
パーツを追加するため、アセンブリスロットを追加します。
「BoxesStep-アセンブリスロット」を選択した状態で"スロットを追加"をクリックします。
"スロットを追加"は2種類ありますが、今クリックした方はパターン化したアセンブリスロットを追加します。
画面右側に[スロットを追加]ウィンドウが表示されます。
今回は、「Pallet」の左側に詰めるように"Box"を配置するように設定を変更します。
"スロットパターンを選択"で"テンプレートから"の"Linear"を選択します。
"方向"を"Y"、"カウント"を"5"、"間隔:Y"を"0"に変更して、"適用"をクリックします。
「BoxesStep-アセンブリスロット」が合計5個になります。
[マニピュレーション]-[選択]をクリックして「BoxesStep-アセンブリスロット」を全て選択し、[移動]をクリックして「PalletStep-アセンブリスロット」上の左側へ移動し位置を調整します。
[ツール]-[スナップ]をクリックすることで、選択しているアセンブリスロットを、Palletの中に配置することができます。
次に、"CylindersStep"をクリックします。
「CylindersStep-アセンブリスロット」を選択し、"既定の製品タイプ"を"Cylinder"に変更します。
「CylindersStep-アセンブリスロット」を追加するために、「CylindersStep-アセンブリスロット」を選択した状態で"スロットを追加’(9つの四角形アイコン)"をクリックします。
"Cylinder"を、3行×3列の合計9個配置するように設定を変更します。
"スロットパターンを選択"で"テンプレートから"の"Block"を選択します。
"パターン"の"X"を"3"、"Y"を"3"、"Z"を"1"に変更して"適用"をクリックします。
「CylindersStep-アセンブリスロット」が合計9個になります。
[選択]で「CylindersStep-アセンブリスロット」を全て選択し、[移動]をクリックして「PalletStep-アセンブリスロット」の右側に位置を調整します。
最後に"CapsStep"をクリックします。
「CapsStep-アセンブリスロット」を選択し、"既定の製品タイプ"を"Cap"に変更します。
アセンブリスロットを追加するために、「CapsStep-アセンブリスロット」を選択した状態で"スロットを追加"をクリックします。
設定が"CylindersStep-アセンブリスロット"の時と同じになっているので、そのまま"適用"をクリックします。
[選択]で「CapsStep-アセンブリスロット」を全て選択し、[移動]をクリックして「CylindersStep – アセンブリステップ」上へ移動し位置を調整します。
ここまでで、アセンブリの定義ができました。
[製品タイプエディタ]-"FullPalletクリックすると、全体像が確認できます。
定義した製品を生成しましょう。アセンブリエディタを閉じます。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Conveyors]から"Conveyor"を3Dワールド上にドラッグ&ドロップします。
「Conveyor」をコピー&ペーストで合計3つにし、PnPで接続して1つのコンベアにします。
[タイプ別モデル]-[PM Flow Components]から"Feeder"を3Dワールド上にドラッグ&ドロップします。
[マニピュレーション]-[PnP]を選択した状態で「Feeder」をドラッグし、「Conveyor」に近づけ接続します。
「Feeder」をクリックし、[コンポーネントプロパティ]ウィンドウ-[ProductCreator]タブから"パーツ"を"FullPallet"に変更します。
シミュレーションを再生します。
"FullPallet"が生成されるようになります。
アセンブリステップでアセンブリスロットの設定をする時に、"既定の製品タイプ"が"Null"の場合、アセンブリエディタ上では黄色のボックスが表示されていますが、シミュレーション中は何も生成されません。
[製品タイプエディタ]ウィンドウ-"CapsStep"を選択し"アセンブリエディタを開く"をクリックします。
アセンブリエディタ上の「CapsStep-アセンブリスロット」を全て選択し、"既定の製品タイプ"を"Null"に変更します。
シミュレーションを再生します。
「CapsStep-アセンブリスロット」は何も生成されなくなります。
次に、プロセスのステートメントを使って製品を生成します。
「Feeder」を削除します。
[eカタログ]ウィンドウ"-[タイプ別モデル]-[PM Flow Components]から"Process Node"を3Dワールド上にドラッグ&ドロップします。
[マニピュレーション]-[PnP]を選択した状態で「Process Node」をドラッグして「Conveyor」に近づけ、接続します。
[エディタ]-[プロセス]を選択し、"Process #1"をクリックします。
[ルーチンプロパティ]ウィンドウから[名前]を"Create"に変更します。
"TransportIn:~"を削除します。
"ステートメント"-"製品作成"クリックし、追加された"Create:~"を先頭に移動します。
"Create:~"を選択し、[ステートメントプロパティ]ウィンドウから"製品タイプ"を"FullPallet"に変更します。
[製品変数名]を"ProductIn"に変更します。
"TransportOut:~"を選択し、[ステートメントプロパティ]ウィンドウから[目的地]を"コンポーネントコンテナへ"に変更します。
シミュレーションを再生します。先ほど同様に、製品が生成できることが確認できます。
"製品作成"ステートメントの"製品タイプ"にアセンブリを設定した場合、[ステートメントプロパティ]ウィンドウに"アセンブリステップ"が表示されます。
"アセンブリステップ"には、"製品タイプ"に指定したアセンブリのアセンブリステップが設定されています。
このプロパティを変更することで、生成するアセンブリステップの変更ができます。
また、"子ステップを含む"にチェックを入れると、アセンブリ製品を生成する際に、子ステップが自動的に生成されるようになります。
"Create:~"を選択し、"アセンブリステップ"をクリックして"PalletStep"以外を削除します。
シミュレーションを再生します。
"PalletStep"のみが生成されます。
"子ステップを含む"にチェックをいれ、シミュレーションを再生します。
"PalletStep"の子ステップである"BoxesStep"と"CylindersStep"も生成されます。
次に、製品をアセンブリステップで分解する方法について説明します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Flow Components]から"Process Node"と"Sink Process"を3Dワールド上にドラッグ&ドロップします。
[マニピュレーション]-[PnP]を選択した状態で「Process Node #2」をドラッグして2つ目の「Conveyor」に近づけ、接続します。
「Sink Process」をコンベアから離れた位置に配置します。
[エディタ]-[フロー]をクリックします。
追加した「Process #1」をクリックし、[ルーチンプロパティ]ウィンドウから[名前]を"Assemble"に変更します。
[プロセスフローエディタ]ウィンドウの"Pallets"を選択した状態で、"Assemble"のプロセスラベル-"Sink"のプロセスラベルと順にクリックし、"Assemble-Sink"のプロセスフローを作成します。
同様に、"Parts"を選択した状態で、"Assemble"のプロセスラベル-"Sink"のプロセスラベルと順にクリックし、"Assemble-Sink"のプロセスフローを作成します。
"Assemble"の"TransportIn:~"をクリックし、[ステートメントプロパティ]ウィンドウから"ソース"を"コンポーネントコンテナから"に変更します。
"Assemble"の"TransportIn:~"を選択した状態で、"ステートメント"-"アセンブリを取得"をクリックします。
"アセンブリを取得"ステートメントは、アセンブリステップの情報を取得し、変数に保存するステートメントです。
今回設定するプロパティについて説明します。
"アセンブリデータソース"は、アセンブリステップの情報の取得元を設定するプロパティです。
"アセンブリインスタンス"と"アセンブリ製品タイプ"の2種類あり、それぞれで設定するプロパティが異なります。
まず、"アセンブリデータソース"を"アセンブリインスタンス"にして設定を行います。
"アセンブリインスタンス"の場合、輸送された製品からアセンブリステップの情報を取得します。
"アセンブリ変数名"には、製品名を設定します。
今回の場合、輸送された製品である"ProductIn"にします。
"アセンブリステップ"は、"最後のステップ(製品あり)"に設定します。
最後のステップとは、アセンブリを生成するときに最後に実体化されるステップを指します。
アセンブリは、[アセンブリエディタ]ウィンドウ上の上層のステップから実体化されるため、最後のステップは最下層のステップになります。
"最後のステップ(製品あり)"の場合、最下層のステップから順番に製品の割り当てをチェックし、割り当てのあるステップの情報を取得します。
今回の場合、最下層のステップは"CapsStep"になります。
しかし、"CapsStep"には製品が割り当てられていないため、"最後のステップ(製品あり)"は、"CylindersStep"になります。
そのため、"AssemblyOrder"に"CylindersStep"の情報が格納されます。
"GetAssembly:~"を選択した状態で"ステートメント"-"トランスポートアウト"をクリックします。
追加された"TransportOut:~"を選択し、[ステートメントプロパティ]ウィンドウから"モード"を"Process an Assembly"に変更します。
このモードは、製品からアセンブリステップを取り出して輸送できます。
"アセンブリ命令変数名"にアセンブリステップの情報が保存されている変数を設定して、輸送するアセンブリステップを指定します。
今回の場合、"アセンブリ取得"ステートメントで"CylindersStep"の情報を格納した"AssemblyOrder"を設定します。
"Cylinders部品"は、このステートメントで輸送されるようになります。
最終行の"TransportOut:~"を選択します。
[ステートメントプロパティ]ウィンドウから[目的地]を"コンポーネントコンテナへ"に変更します。
シミュレーションを再生します。
製品が"Assemble"で分解され、"Cylinder"は"Sink"へ、残った製品はそのままコンベアへ輸送されます。
"アセンブリを取得"ステートメントの[ステートメントプロパティ]ウィンドウから"子ステップを含む"にチェックを入れると、輸送するアセンブリステップに子ステップが存在する場合、子ステップの情報も合わせて取得できます。
"GetAssembly:~"をクリックします。
[ステートメントプロパティ]から"アセンブリステップ"を"最初の完全なステップ"に変更します。
完全なステップとは、すべてのアセンブリスロットに製品が割り当てられている、アセンブリステップのことを言います。
今回の場合、"PalletStep"が"最初の完全なステップ"となります。
子ステップを含む"にチェックを入れていないことを確認してシミュレーションを再生します。
"AssemblyOrder"には"PalletStep"の情報が保存されており、"PalletStep"とそれ以外に分けて輸送されます。
"子ステップを含む"にチェックを入れて、再度シミュレーションを再生します。
"AssemblyOrder"には"PalletStep"とその子ステップの情報が保存されているため、全て"Sink"へ輸送されます。
複数の製品を輸送する時は、下層のステップから順に輸送されます。
"リストとしてリターン"にチェックを入れると、アセンブリの情報を取得して格納する際に、製品インスタンスのリストとして取得できます。
製品インスタンスのリストにすることで、"トランスポートアウト"ステートメントの"モード"が"Process an Assembly"でなくても、アセンブリステップで製品を分解できます。
"アセンブリデータソース"が"アセンブリインスタンス"の場合の設定方法は以上になります。
次に"アセンブリデータソース"が"アセンブリ製品タイプ"の場合の設定を行います。
"アセンブリ製品タイプ"は、製品タイプエディタに登録されているアセンブリからアセンブリステップの情報を取得します。
"アセンブリデータソース"を"アセンブリ製品タイプ"に変更します。
"アセンブリ"には、製品タイプエディタに登録されているアセンブリから、情報を取得するアセンブリを選択します。
"アセンブリ"を"FullPallet"に変更します。
"アセンブリステップ"は、情報を取得するアセンブリステップを設定します。
選択できるアセンブリステップは、製品タイプエディタに設定した"アセンブリ"に設定したアセンブリに定義されているアセンブリステップのみです。
今回の場合、"FullPallet"に定義されているアセンブリステップが設定できます。
生成するアセンブリステップを追加/削除できるため、任意のステップに変更します。
シミュレーションを再生します。
"アセンブリステップ"で設定したパーツのみが"Sink"へ輸送されるようになりました。
シミュレーション中に製品を分解する方法についての説明は以上になります。
次に、輸送されたパーツを組み合わせて製品を作成する方法について説明します。
"GetAssembly:~"を選択し、"FullPallet"の情報を全て取得するように変更します。
"ステートメント"-"トランスポートイン"をクリックして、"GetAssembly:~"の後に"TransportIn:~"を追加します。
[ステートメントプロパティ]ウィンドウから"モード"を"Process an Assembly"、"アセンブリ変数名"を"ProductIn"に変更します。4行目の"TransportOut:~"を削除します。
各パーツを生成する"Feeder Process"を設定します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Flow Components]から"Feeder Process"を3つ配置します。
「Feeder Process」を選択し、[コンポーネントプロパティ]ウィンドウ-[ProductCreator]タブから"パーツ"をそれぞれ"Box"、"Cylinder"、"Cap"に変更します。
シミュレーション再生中の様子を確認しやすくするために、「Feeder Process」を手前に移動します。
[エディタ]-[フロー]をクリックして、プロセスフローエディタを開きます。
"Parts"と"Pallets"のフローステップの先頭に"Feeder"を追加し、フローステップの"Feeder"を選択して、3Dワールド上の"Feeder"のプロセスラベル-"Assemble"のプロセスノードと順にクリックして、"Feeder-Assemble-Sink"のプロセスフローを作成します。
"Create"をクリックします。
"Create:~"を選択して、[ステートメントプロパティ]から"アセンブリステップ"を"PalletStep"のみにします。
シミュレーションを再生します。
"PalletStep"上にパーツは配置されますが、アセンブリスロットが全ての製品を受け入れる設定なため、製品タイプを問わずパーツが配置されます。
アセンブリスロットの設定を変更してフィルタリングすることで、アセンブリステップの設定通りにパーツを配置できます。
[製品タイプエディタ]ウィンドウ-"BoxesStep"を選択して"アセンブリエディタを開く"をクリックします。
「BoxesStep-アセンブリスロット」を全て選択し、[プロパティ]ウィンドウから"全製品タイプを受け入れ"のチェックを外して"受け入れられた製品タイプ"に"Box"を追加します。
同様の手順で、"CylindersStep"、"CapsStep"のアセンブリスロットの設定も変更します。
シミュレーションを再生します。アセンブリステップの設定通りにパーツが配置されるようになります。
アセンブリスロットの"オーダー・インデックス"を設定することで、アセンブリスロットを配置する順番を変更できます。
"Box"を生成する「Feeder Process」を選択して、コピー&ペーストで4つ追加します。
[エディタ]-[フロー]を選択します。
[プロセスフローエディタ]ウィンドウの"Parts"をクリックし、"Feeder-Assemble"のプロセスフローにコピー&ペーストした「Feeder」を追記します。
[プロセスフローエディタ]ウィンドウの"Pallets"をクリックし、同様にプロセスフローを追記します。
シミュレーションを再生すると、"Box"は1つずつ"Pallet"に配置されます。
"オーダー・インデックス"を変更して、"BoxesStep"が同時に配置されるようにします。
[製品タイプエディタ]ウィンドウ-"BoxesStep"を選択して"アセンブリエディタを開く"をクリックします。
「BoxesStep-アセンブリスロット」を複数選択で全て選択し、[プロパティ]ウィンドウから"オーダー・インデックス"を"1"に変更します。
アセンブリエディタを閉じます。
シミュレーションを再生します。
"Box"を"Pallet"に配置する時に、同時に配置されるようになりました。
"GetAssembly:~"の"アセンブリステップ"を設定することで、生成するアセンブリステップを指定できます。
"Assemble"の"GetAssembly:~"を選択して、[ステートメントプロパティ]ウィンドウから"アセンブリステップ"の"CylindersStep"以外を削除します。
"子ステップを含む"のチェックを外して、シミュレーションを再生します。
"Pallet"には"Cylinder"のみが配置されるようになります。
製品を組み立てる際に、既にパーツが配置済みのアセンブリステップがある場合は、そのアセンブリステップの輸送はスキップされます。
"Create"プロセスの"Create:~"ステートメントをクリックします。
[ステートメントプロパティ]ウィンドウから"アセンブリステップ"に"CylindersStep"を追加します。
"Assemble"をクリックしてプロセスルーチンを開きます。
"GetAssembly:~"を選択して、すべてのアセンブリステップを生成するように変更します
シミュレーションを再生します。
あらかじめ"PalletStep"上に配置されている"CylindersStep"の輸送はスキップされます。
以上で、「アセンブリ機能を使ってみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

アセンブリについて知ろう

シミュレーション中に製品の組立や分解をするため、複数の製品から形成されたアセンブリ構造を設定する方法
https://youtu.be/j3KcsbSh8ek
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_048.zip

本動画では、アセンブリについて説明します。
アセンブリとは、製品をアセンブリステップという階層的な構造で定義したものです。
アセンブリを使用することで、シミュレーション中に製品を組み立て、分解することができます。
「アセンブリについて知ろう.vcmx」を開きます。
アセンブリは、[製品タイプエディタ]で定義します。
[プロセス]タブ-[エディタ]-[製品]をクリックします。
今回使用するファイルでは、"FullPallet"というアセンブリが定義されています。
[製品タイプエディタ]ウィンドウ上の、アセンブリ横の＋アイコクリックすると、アセンブリステップを確認できます。
アセンブリステップには、アセンブリスロットが1つ以上配置されている必要があります。
[製品タイプエディタ]ウィンドウ上でアセンブリにカーソルを合わせると、[アセンブリエディタを開く]が表示されます。
[アセンブリエディタを開く]をクリックするとアセンブリエディタが開き、定義されているアセンブリスロットを確認できます。
アセンブリスロットは、製品のパーツを割り当てるためのプレースホルダーです。
配布したファイルの設定の場合、1番目のアセンブリステップである"PalletStep"のアセンブリスロットに"Pallet"、2番目以降のアセンブリステップのアセンブリスロットには"Pallet"の上に配置しているパーツを割り当てています。
アセンブリステップは親子関係も定義します。
今回の場合、"Part1Step"と"Part2Step"は"SheetStep"の子ステップであり、"SheetStep"は"PalletStep"の子ステップとなります。
アセンブリは、定義した親子関係に基づいて、パーツをアタッチして製品を組み立てます。
シミュレーション中に組み立てた製品を操作して、パーツ間の親子関係を確認します。
アセンブリエディタを閉じて、シミュレーションを再生します。製品が組み立てられたタイミングで、シミュレーションを停止します。
子ステップのパーツを操作します。
「Part1」と「Part2」をドラッグして移動します。
「Part1」は"Part1Step"、「Part2」は"Part2Step"に割り当てられたパーツです。
親ステップのパーツである「Sheet」は移動せず、Part1とPart2がそれぞれ独立して移動します。
親ステップのパーツを操作します。
「Sheet」をドラッグして移動します。
「Sheet」は"Part1Step"と"Part2Step"の親ステップである"SheetStep"に割り当てられたパーツです。
「Sheet」を移動すると、子ステップのパーツである「Part1」と「Part2」も同じように移動します。
「Pallet」をドラッグして移動します。
「Pallet」は、"SheetStep"の親ステップである"PalletStep"に割り当てられたパーツです。
「Pallet」を移動すると、子ステップである「Sheet」も同じように移動します。
「Sheet」が移動したため、"SheetStep"の子ステップのパーツである「Part1」と「Part2」も同じように移動します。
以上で、「アセンブリについて知ろう」を終わります。
ご視聴ありがとうございました。

=================================================================================

オリジナルの台車を使って製品を輸送してみよう

オリジナルの台車を使って、製品を搬出する方法。
（アタッチステートメント、デタッチステートメント、製品ポジションフレーム、TransportLocation）
https://youtu.be/LW6dDeLCKio
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_156.zip

本動画では、作業者が製品を輸送する時に、オリジナルの台車を使うようにする方法を説明します。
シミュレーション中に台車を生成し、その生成した台車を使って、製品を輸送するようにします。
初めに、レイアウトを作成します。
まず、必要なコンポーネントを配置します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Facilities - Factory]から、"Mobile Manual WorkStation"を3Dワールド上にドラッグ&ドロップします。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Products and Containers]から"Box"を3Dワールド上にドラッグ&ドロップします。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Flow Components]から、"Feeder Process"と"Process Node"と"To Conveyor Process"を3Dワールド上にドラッグ&ドロップします。
「Feeder Process」と「Process Node」はコピー&ペーストで2つにします。
「Feeder Process」の名前は、それぞれ"Feeder Process(台車)"、"Feeder Process(製品)"に変更します。
「Process Node」の名前は、それぞれ"Place Process"、"Pick Process"に変更します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Conveyers]から、"Conveyor"を3Dワールド上にドラッグ&ドロップします。
[マニピュレーション]-[PnP]を選択した状態で、「To Conveyor Process」を「Conveyor」に近づけ、接続します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Resources]から"Human (Anna)"を3Dワールド上にドラッグ&ドロップします。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Transport Controllers]から"Human Transport Controller"を3Dワールド上にドラッグ&ドロップします。
[接続]-[インターフェース]をクリックします。
"Human"と"Human Transport Controller"をインターフェース接続します。
[インターフェース]を再度クリックします。
これで、コンポーネントの用意ができました。
シミュレーション再生中の様子を見やすくするために、画面のように配置を変更してください。
次に、台車と製品を[製品タイプエディタ]に登録します。
[プロセス]タブ-[エディタ]-[製品]をクリックします。
"フローグループ番号1"をクリックし、"製品の定義"-"製品タイプを追加"を2回クリックします。
"VC_Can"は使用しないので、削除します。
"製品タイプ番号1"をクリックします。
[プロパティ]ウィンドウから[Name]を"台車"に変更します。
"Pick Component from 3D world"をクリックして、3Dワールド上の"Mobile Manual WorkStation"をクリックします。
"製品タイプ番号2"をクリックします。
[プロパティ]ウィンドウから[Name]を"製品"に変更します。
"Pick Component from 3D world"をクリックして、3Dワールド上の"Box"をクリックします。
これで、使用する台車と製品の設定ができました。
次に、各プロセスにフローとステートメントを追加して、台車や製品を搬入・搬出するようにします。
[エディタ]-[プロセス]をクリックします。
「Place Process」の「Process #1」をクリックして、[ルーチンプロパティ]ウィンドウから名前を「Place Product」に変更します。
「Pick Process」の「Process #1」をクリックして、[ルーチンプロパティ]ウィンドウから名前を「Pick Product」に変更します。
「Place Product」では、「台車を搬入し、その後製品を搬入して台車の上に載せた後、台車を搬出する」ように設定します。
「Pick Product」では、「製品が載った台車を搬入し、製品をコンベアへ搬出した後、残った台車を「Place Product」へ搬出する」ように設定します。
[エディタ]-[フロー]をクリックします。
"フローグループ番号1"に"Feeder"-"Place Product"-"Pick Product"-"ToConveyor"のプロセスフローを設定します。
トランスポートリンクには、"Human Transport Controller"を割り当てます。
「Place Product」のプロセスの設定をします。
このプロセスでは①台車を搬入する。②製品を搬入する。③製品を台車に載せる。④台車を搬出する。の4つの処理を順に実行するようにステートメントを設定します。
まず、台車を搬入する設定をします。
"TransportIn"をクリックします。
[ステートメントプロパティ]ウィンドウから、[製品変数名]を「Cart」に変更します。
"製品フィルター"を展開します。
"製品タイプ"の"使用可能な製品タイプ"を"台車"に設定します。
チェックボックスにチェックを入れて、フィルターを有効にします。
これで、台車を搬入する設定ができました。
次に、製品を搬入する設定をします。
"TransportIn:~"をコピー&ペーストして、2行目に追加します。
2行目の"TransportIn:~"をクリックします。
[ステートメントプロパティ]ウィンドウから、[製品変数名]を「Product」に変更します。
"製品フィルター"-"製品タイプ"-"使用可能な製品タイプ"を「製品」に変更します。
これで、製品を搬入する設定ができました。
次に、製品を台車の上に載せる設定をします。
アタッチステートメントを使って、台車と製品を1つのコンポーネントにします。
"TransportIn:製品~"を選択した状態で、"ステートメント"-"アタッチ"をクリックします。
追加された"Attach"の設定を変更します。
[ステートメントプロパティ]ウィンドウから、[親]を「Cart」、[子]を「Product」に変更します。
これで、製品を台車の上に載せる設定ができました。
最後に、台車を搬出する設定をします。
"TransportOut:~"をクリックします。
[ステートメントプロパティ]ウィンドウから、[製品変数名]を「Cart」に変更します。
これで、「Place Product」の設定ができました。
次に、「Pick Product」を設定します。
このプロセスでは、①製品が載った台車を搬入する。②台車から製品を取り出す。③製品を搬出する。④台車を「Place Product」へ搬出する。の4つの処理を順に実行するようにステートメントを設定します。
まず、製品が載った台車を搬入する設定をします。
"TransportIn:~"をクリックします。
[ステートメントプロパティ]ウィンドウから[製品変数名]を「Cart」に変更します。
これで、製品が載った台車を搬入する設定ができました。
次に、台車から製品を取り出す設定をします。
デタッチステートメントを使って、1つのコンポーネントになった製品と台車を、別々のコンポーネントにします。
"TransportIn:~"を選択した状態で、"ステートメント"-"デタッチ"をクリックします。
追加された"Detach"の設定を変更します。
[ステートメントプロパティ]ウィンドウから[製品変数名]を「Cart」、[デタッチ変数名]を「Product」に変更します。
これで、台車から製品を取り出す設定ができました。
次に、製品を搬出する設定をします。
"TransportOut:~"をクリックします。
[ステートメントプロパティ]ウィンドウから[製品変数名]を「Product」に変更します。
これで、製品を搬出する設定ができました。
最後に、台車を「Place Product」へ搬出する設定をします。
今の設定では、台車は"ToConveyor"へ搬出されます。台車を「Place Product」へ搬出するには、①「Place Product」のフローステップを取得する。
②「台車」の次のフローステップの情報を、前工程①で取得した情報に書き換える。
③台車を搬出 する。の3つの処理を順に行うようにし、"Pick Product"-"Place Product"のプロセスフローを設定する必要があります。
まず、「Place Product」のフローステップを取得する設定をします。
"TransportOut:~"を選択した状態で、"ステートメント"-"フローステップを取得"をクリックします。
追加された"GetFlowStep:~"の設定を変更します。
[ステートメントプロパティ]ウィンドウから"Flow Group"を"フローグループ番号 1"に変更します。
"FlowStep"をクリックして、取得するフローステップを選択します。
フローステップの名前は、デフォルトでは"Flow Step"になります。
先頭の番号は、[プロセスフローエディタ]ウィンドウ上で左から順に[0]、[1]、[2]、[3]となっており、今回の場合は[0]は"Feeder"、[1]は"Place Product"、[2]は"Pick Product"、[3]は"ToCoveyor"のフローステップになります。
"Flow Step"を"[1]FlowStep"に変更します。
これで、「Place Product」のフローステップの情報を取得する設定ができました。
次に、台車の次のフローステップの情報を、取得した情報で上書きする設定をします。
"GetFlowStep:~"を選択した状態で、"ステートメント"-"次のフローステップを設定"をクリックします。
追加された"SetNextFlowStep:~"の設定を変更します。
[ステートメントプロパティ]ウィンドウから[ProductVariableName]を「Cart」に変更します。
これで、台車の次のフローステップの情報を、取得した情報で上書きする設定ができました。
今使用した2つのステートメントの詳細は、別動画「製品のフローを定義してみよう」を参照ください。
次に、台車を搬出する設定をします。
"SetNextFlowStep:~"を選択した状態で、"ステートメント"-"トランスポートアウト"をクリックします。
追加された"TransportOut"の設定を変更します。
[ステートメントプロパティ]ウィンドウから[製品変数名]を「Cart」に変更します。
これで、台車を搬出する設定ができました。
最後に、"Pick Process"-"Place Process"のプロセスフローを設定します。トランスポートリンクには、"Human Transport Controller"を割り当てます。
このプロセスフローと、3つのステートメントで、製品を降ろした台車を「Place Product」へ搬出できるようになりました。
これで、「Pick Product」の設定ができました。
コンポーネントを生成するFeeder Processの設定を変更して、台車と製品を生成するようにします。
「Feeder Process(台車)」をクリックします。
[コンポーネントプロパティ]ウィンドウ-[ProductCreator]タブをクリックします。
"パーツ"を"台車"、"制限"を"1"に変更します。
「Feeder Process(製品)」をクリックします。
[コンポーネントプロパティ]ウィンドウ-[ProductCreator]タブから、[パーツ]を「製品」に変更します。
これで、台車と製品が生成されるようになりました。
作業者が、台車や製品を取る時にかかる時間を0に変更して、シミュレーション再生中の様子を見やすくします。
「Human Transport Controller」をクリックします。
[コンポーネントプロパティ]ウィンドウ-[LinkDefaults]タブから"PickTime"を"0s"、"PlaceTime"を"0s"に変更します。
シミュレーションを再生し、台車が生成されたタイミングで一時停止します。
シミュレーション再生中の各コンポーネントの位置を修正します。
まず、台車の位置を変更します。
Place Productのようなプロセスにワークを搬入する際は、TransportIn等の製品を搬入するステートメントの"製品ポジションフレーム"プロパティに設定しているフレームの位置とワークの原点が重なるように搬入します。
台車をクリックして、[ホーム]タブ-[原点]-[移動]をクリックすると、台車の原点座標が確認できます。
今回の"台車"の場合、台車の原点が角にあり、台車を搬入するステートメントの"製品ポジションフレーム"を"MainFrame"に設定しています。
台車の角が"MainFrame"と重なるように搬入するので、宙に浮いた状態になっています。
"MainFrame"の位置は、3Dワールドツールバーの"フレームタイプ"で表示できます。
台車を搬入する時の"製品ポジションフレーム"を変更して、台車を床に面して配置するようにします。
プロセスには、"MainFrame"の他に"ResourceLocation"という名前のフレームが定義されています。
"ResourceLocation"は、作業者などのリソースがタスクを行う時の位置として使用するフレームで、床に面するように定義されています。
作業者の原点は、台車と同じく床に面しています。
"製品ポジションフレーム"を"ResourceLocation"に変更することで、台車が床に面して配置されるようになります。
台車を搬入するステートメントの"製品ポジションフレーム"を"MainFrame"から"ResourceLocation"に変更します。
"Feeder"の"TransportIn:~"をクリックします。
"製品ポジションフレーム"を"ResourceLocation"に変更します。
"Place Product"をクリックします。
"TransportIn:台車~"をクリックします。
"製品ポジションフレーム"を"ResourceLocation"に変更します。
"Pick Product"をクリックします。
"TransportIn:~"をクリックします。
"製品ポジションフレーム"を"ResourceLocation"に変更します。
シミュレーションをリセットして、再生します。
台車が床に面する位置に配置するようになりました。
シミュレーションを一時停止します。
次に、作業者が台車を持つ時の、台車の位置を変更します。
作業者が台車を持つ時の位置は、台車の原点と作業者の"TransportLocation"で決まります。
シミュレーションをリセットします。
まず、台車の原点を変更します。
[ホーム]タブをクリックして、「Mobile Manual Workstation」をクリックします。
フレームの表示は、非表示に戻します。
[原点]-[移動]をクリックし、原点の位置を「台車を運ぶ時の作業者の位置」になるように変更して、[原点を移動]ウィンドウの"適用"をクリックします。
原点を変更したら、変更を反映するために、製品タイプを更新します。
[プロセス]タブ-[エディタ]-[製品]をクリックします。
[製品タイプエディタ]ウィンドウの"台車"をクリックします。
[プロパティ]ウィンドウから"コンポーネントURI"を一度空欄にしてエンターキーを押下した後、"Pick Component from 3D world"をクリックして"Mobile Manual WorkStation"をクリックします。
これで、台車の原点を変更できました。
次に、作業者の"TransportLocation"を変更します。
「Human (Anna)」をクリックします。
[コンポーネントプロパティ]ウィンドウ-[Transport]タブをクリックします。
[Transport]タブは、リソースが製品を運ぶときの、製品の位置などを設定できます。
"ProductType"は、今表示している"TransportLocation"以下の設定が、どの製品タイプに適用されるかの設定です。
"Default <Any>"は、リストにない全ての製品タイプに適用される設定になります。
"TransportLocation"は、製品を搬出する時の製品の位置の設定です。リソースの原点を基準としたオフセットで定義します。
"ShowLocation"にチェックを入れると、搬出する時の製品の位置が表示されます。
今回の場合、全ての製品は「Human (Anna)」の原点を基準に(400,0,1200,0,0,0)の位置に置かれます。
製品を搬出する時の位置はそのままでいいので、台車を搬出するための新しい設定を追加します。
"ProductType"をクリックして、"Add New…"をクリックします。
"ProductTypeName"を"台車"に変更して、"Add Location"をクリックします。
これで、"台車"を搬出する時専用の位置を設定できます。
今回の場合、"台車"の原点から搬出したいので、"TransportLocation"は"0,0,0"のままにします。
これで、作業者が台車を輸送する時の、台車の位置が変更できました。
シミュレーションを再生します。
台車を搬出する時の台車の位置が変更できました。
作業者の作業位置を変更するためなどで"ResourceLocation"の設定を変更する必要がある場合、その変更が"ResourceLocation"を基準として合わせた台車の位置にも影響します。
そういった変更が予想される場合、既存のフレームを軸にして位置を変更するのではなく、この後の説明のように、台車の位置を指定するフレームを追加して位置を変更してください。
最後に、台車に載せる時の製品の位置を変更します。
製品の位置は、製品の原点と製品を搬入するステートメントの"製品ポジションフレーム"で決まります。
"製品"の場合、製品を搬入するステートメントの"製品ポジションフレーム"が"MainFrame"に設定されているので、製品の原点が"MainFrame"と重なるように配置され、台車と重なっていました。
フレームを追加して、製品を台車の上に配置するようにします。
まず、「Place Process」の"MainFrame"から台車までの距離を測定します。
"Place Product"に台車を搬入した時点で一時停止します。
視点を測定しやすい位置に変更します。
[ツール]-[測定]をクリックして、「Place Process」の"MainFrame"から台車の一番上の面の中央までの距離を測定します。
これで、"MainFrame"から台車までの距離が測定できました。
次に、測定した距離を基にフレームを作成します。
今回は、[ヘルパーツール]の[フレームを作成]機能を使います。
[測定]ウィンドウを閉じます。
「Place Process」をクリックします。
[ヘルパーツール]-[フレームを作成]をクリックします。
[フレームを作成]ウィンドウから、"新しいフレーム名"を"ProductLocation"に設定します。
"ここからロケーションをコピー"からフレームを選択することで、選択したフレームの座標を"フレームの位置"にコピーすることができます。
今回は、"MainFrame"を基準として距離を測定したので、"ここからロケーションをコピー"を"MainFrame"に変更します。
"フレームの位置"が"MainFrame"に更新されたので、この値に先ほど測定した距離を反映させます。
Tzには、箱の底の厚さ10mmも追加でオフセットに設定します。
"フレームの位置"を設定できたら、"フレームを作成"をクリックします。
これで、台車の上に製品を置くためのフレームを作成できました。
最後に、製品を搬入するステートメントの製品ポジションフレームを変更します。
"閉じる"をクリックして、[フレームを作成]ウィンドウを閉じます。
「Place Product」の"TransportIn:製品～"をクリックします。
[ステートメントプロパティ]ウィンドウから、"製品ポジションフレーム"を"ProductLocation"に変更します。
これで、製品が台車の一番上の中央に配置するようになります。
シミュレーションをリセットして、再度再生します。
作業者が製品を輸送する時に、台車を使うようになりました。
以上で、「オリジナルの台車を使って製品を輸送してみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

グローバルなシグナルを作ろう

グローバルなシグナルを作成し、値を確認する、または変更する方法（Signal Relay）
https://youtu.be/jf8wQI6eYgo
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_189.zip

グローバルなシグナルを作成し、値を確認する、または変更する方法について説明します。
事前ファイル「SignalRelay.vcmx」を開きます。
eカタログ、[タイプ別モデル]-[Misc]-[Visual Components]から、「Signal Relay」を配置します。
ダブルクリックすることで、3Dワールドの原点に配置できます。
ドラッグ＆ドロップすることで、マウスボタンをはなした位置に配置できます。
[プロセス]-[ヘルパーツール]-[シグナルをクリエイト]でシグナルを追加することができますが、Essentialsライセンスではシグナルを削除できません。
Signal Relayを使用すれば、Essentialsライセンスでもシグナルを追加、削除できます。
Professional/Premiumライセンスを使用している場合は、[モデリング]タブでコンポーネントにシグナルを追加・削除できます。
動画「プロパティやシグナルの変化時にPythonを実行しよう」を参照してください。
[コンポーネントプロパティ]ウィンドウの[既定]タブを表示します。
Signal Relayにシグナルを追加します。
[SignalName]でシグナルの名前、[SignalType]でシグナルのデータ型を設定します。
追加できるシグナルのデータ型は、ブール型、整数型、実数型、文字列型の4種類です。
[Create signal]を選択することで、新しいシグナルを追加できます。
[SignalName]をAに変更し、[Create signal]を選択します。
[SignalName]には、日本語、数字、記号も使用可能です。
3DワールドのSignal Relayモデル上部に、追加したシグナルの名前と、現在の値が表示されます。
シグナルAの現在の値は、Falseです。
同じ名前のシグナルが、既に存在している場合、シグナルは追加されず、[出力]ウィンドウにメッセージが表示されます。
複数のシグナルを一括で追加する場合、[コンポーネントプロパティ]ウィンドウの[Import]タブを使用します。
[CSV-File]で、追加するシグナルのリストを指定します。
読込み可能なファイル形式は、CSVファイルとテキストファイルです。
CSVファイルの文字コードに制限はなく、どの文字コードを使用していてもImportで読み込む際にUTF-8に変換できます。
ファイルのパスや名前に日本語を含むことも可能です。
ただし、ファイルパス(URI)に、ピリオドが含まれている場合、ピリオド以降を拡張子と認識し、エラーが発生するため、注意が必要です。
付属ファイル「SignalList.csv」を開きます。
1列目にシグナルの名前、2列目にシグナルのデータ型を記載する必要があります。
実数型シグナルを追加する場合、Real、Double、Floatのどれを記載しても、追加可能です。
Geminiの画面を表示します。
[CSV-File]の[...]を選択します。
[開く]ウィンドウで付属ファイルを選択し、[開く]をクリックします。
[Import]を選択します。
3DワールドのSignal Relayモデル上部に、リストに記載されたシグナルが追加されたことがわかります。
同じ名前のシグナルが、既に存在している場合、語尾にアンダーラインと番号をつけ、シグナルを追加します。
[出力]ウィンドウに、追加したシグナルの名前とデータ型が表示されます。
不正なデータ型が含まれている場合、そのシグナルは追加せず、[出力]ウィンドウにメッセージを表示します。
SignalListの10行目が追加できないデータ型であったため、追加に失敗したことが表示されています。
3Dワールドに表示されるシグナルの大きさを変更する場合、[既定]タブのTextSizeを変更します。
大きさは、Small、Medium、Largeの3段階です。
シグナルを削除する場合、[Delete signal]を選択します。
削除するシグナルは、[SignalName]で指定できます。
すべてのシグナルを一括で削除する場合、[Delete all signals]を選択します。
3Dワールドで、すべてのシグナルが削除されたことがわかります。
Signal Relayのシグナルと、他のコンポーネントのシグナルを接続することで、複数のコンポーネントのシグナルを同時に確認できます。
Signal Relayにシグナルを追加します。
[SignalName]をOnConveyor、[SignalType]をBooleanに変更します。
[Create signal]を選択します。
同様に、名前がProductCount、データ型がIntegerのシグナルを追加します。
[Connect]タブで、Signal Relayと他のコンポーネントのシグナルを接続します。
[接続]-[シグナル]ではブール型のみが対象ですが、Signal RelayのConnectはブール型以外のシグナルも接続できます。
[SelectedSignal]は、Signal Relay側のシグナルを選択できます。
OnConveyorを選択します。
[TargetComponent]では、接続先のコンポーネント、[TargetSignal]では、接続先のシグナルを選択できます。
[TargetComponent]はConveyor、[TargetSignal]はTransitionSignalです。
TransitionSignalは、コンベアの製品の在荷を通知します。
[Connect]を選択することで、接続が完了し、[出力]ウィンドウにメッセージが表示されます。
シグナル同士のデータ型が一致しない場合、接続できません。
接続に失敗すると、[出力]ウィンドウにメッセージが表示されます。
同様に、Signal RelayのProductCountと、Conveyor SensorのCounterSignalを接続します。
CounterSignalは、Conveyor Sensorが検出した製品の個数を値に持ちます。
シミュレーションを実行します。
製品がConveyor上を移動し始めた時、OnConveyorがTrueになったことがわかります。
製品がConveyor Sensorを通過した時、ProductCountに1加算されたことがわかります。
シミュレーションをリセットします。
現在、3Dワールドに表示されているシグナルは、値が変化する時、3Dワールドの表示が更新されます。
[コンポーネントプロパティ]ウィンドウの[既定]タブ-[VisualizationMode]で、更新する条件を変更できます。
Eventの場合、値が変化する時、表示が更新されます。
Do not Visualizeの場合、表示は更新されません。
Cyclicの場合、[UpdateFrequency]で設定した数値分の1秒間隔で更新されます。
10Hzの場合、0.1秒です。
Signal Relayから他のコンポーネントのシグナルを、変更することもできます。
[接続]-[シグナル]ではブール型のみが対象ですが、Signal RelayのWriteはブール型以外の値も変更できます。
Signal Feederは、文字列型シグナルに製品タイプを入力することで、製品を生成できます。
[プロセス]タブ-[エディタ]グループの[製品]を選択し、[製品タイプエディタ]ウィンドウで、製品タイプの確認と追加ができます。
[コンポーネントプロパティ]ウィンドウの[SignalName]をProductType、[SignalType]をStringに変更します。
[Create signal]を選択します。
同様に、名前がStopperRelease、データ型がBooleanのシグナルを追加します。
[Connect]タブで、シグナルを接続します。
[SelectedSignal]でProductType、[TargetComponent]でSignal Feeder、[TargetSignal]でCreateSignalを選択します。
[Connect]を選択します。
同様に、Signal RelayのStopperReleaseと、Bladder stopperのReleaseSignalを接続します。
シミュレーション実行前に[Write]でシグナルの値を設定しても、初期値として反映されることはありません。
シミュレーション実行中、[Write]タブで、シグナルの値を変更できます。
[Write]タブのシグナルの値の表示は、シミュレーション実行中の現在値とは連動しません。
例えば、シミュレーション開始直後はFalse、途中から[Write]タブでTrueに変更、[接続]-[シグナル]でFalseに変更した場合、[Write]タブの表示はFalseに更新されません。
シミュレーションを実行します。
[ProductType]に、VC_Cylinderと入力し、エンターキーを押します。
製品が生成されたことがわかります。
Signal Relayで、シグナルの値を変更すると、[出力]ウィンドウにメッセージが表示されます。
Bladder stopperが製品を停止させています。
[StopperRelease]に、チェックをつけます。
製品が解放されたことがわかります。
シミュレーションをリセットします。
グローバルなシグナルを作成し、値を確認する、または変更する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

グローバルな変数を作ろう(1/2)

eカタログのモデルを使用して、グローバルな変数を作成する方法（PM Global Variables）
（関連動画：カーブするコンベアを作ってみよう、条件を満たすまで待機するプログラムを作ってみよう）
https://youtu.be/NCmvcvCr_oM
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_190_p1.zip

eカタログのモデルを使用して、グローバル変数を作成する方法について説明します。
[モデリング]において、コンポーネントにプロパティを追加する場合は、動画「カーブするコンベアを作ってみよう」を参照してください。
事前ファイル「PM Global Variables_before.vcmx」を開きます。
eカタログ、[タイプ別モデル]-[Misc]-[Visual Components]から、「PM Global Variables」を配置します。
ダブルクリックすることで、3Dワールドの原点に配置できます。
ドラッグ＆ドロップすることで、マウスボタンをはなした位置に配置できます。
PM Global Variablesにプロパティを追加します。
[コンポーネントプロパティ]ウィンドウの[UserVariables]タブを表示します。
[Name]で変数の名前、[Type]で変数のデータ型を設定します。
追加できる変数のデータ型は、実数型、整数型、文字列型、ブール型、分布型の5種類です。
設定するTypeによって、設定可能な項目が異なります。
実数型Realの場合、[MinValue]と[MaxValue]に数値を入力し、値の最小と最大を設定できます。
空欄にすることで、値の最小と最大を設定しないことも可能です。
[Units]を設定することで、変数の値に単位をつけることができます。
設定可能な単位は、Timeの場合、秒、Distanceの場合、ミリメートルです。
単位を設定しない場合、[Units]で空欄を選択します。
整数型Integerの場合、[MinValue]と[MaxValue]のみ設定できます。
分布型Distributionの場合、[Units]のみ設定できます。
文字列型Stringとブール型Booleanに設定可能な項目はありません。
[Define Variable]を選択することで、新しい変数を追加できます。
[Name]をA、[Type]をBooleanに変更し、[Define Variable]を選択します。
[Name]には日本語、数字、記号、全角スペース、半角スペースも使用可能です。
[UserVariables]タブに、Aが追加されたことがわかります。
同様に、NameがB、C、Dの変数を追加します。
Typeは、Real、Integer、Stringです。
現在、Aの初期値はFalseです。
Aにチェックをつけ、シミュレーションを実行することで、初期値をTrueに変更できます。
[既定]タブの[AutomaticallyResetVariables]のチェックを外すことで、シミュレーションリセット時、初期値に戻さないことも可能です。
チェックが入っている場合、シミュレーション中に変更した値は、シミュレーションリセット時、初期値に戻ります。
[UserVariables]タブの[Remove Variable]を選択することで、Nameで指定している変数を削除できます。
追加した変数をすべて削除する場合、[Remove All Variables]を選択します。
すべての変数が削除されたことがわかります。
PM Global Variablesで追加した変数を使用し、作業を変更することもできます。
現在の作業内容を確認します。
[プロセス]タブを開き、[エディタ]グループ-[プロセス]を選択することで、作業内容の確認と編集が可能です。
Process#1を選択します。
2種類の製品が交互に生成されます。
製品を生成する間隔は、3秒です。
シミュレーションを実行し、確認します。
青いブロックと、黄色の円柱を、交互に生成していることがわかります。
シミュレーションをリセットします。
変数の値が1の場合、ブロックを生成し、2の場合、円柱を生成し、それ以外の場合、何も生成しないように、変更します。
変数を追加するため、PM Global Variablesを選択します。
[Name]は、Product、[Type]は、Integerです。
[Define Variables]を選択し、変数を追加します。
Process#1の[ステートメント]アイコンを選択し、追加可能なステートメントの一覧を表示します。
[その他のステートメント]から[プロパティ取得]を選択します。
プロパティ取得についての詳細は、動画「条件を満たすまで待機するプログラムを作ってみよう」を参照してください。
プロパティ取得ステートメントは、シミュレーション開始前から、3Dワールドに存在するコンポーネントのプロパティを取得できます。
取得可能なプロパティは、ブール型、整数型、実数型、文字列型、ベクトル型、行列型の6種類です。
GetPropertyを、先頭にドラッグ＆ドロップし、移動させます。
[ステートメントプロパティ]ウィンドウで、取得するプロパティを指定できます。
[選択したコンポーネント]では、コンポーネントを選択できます。
PM Global Variablesを選択します。
[選択したビヘイビア]を設定することで、ビヘイビアが持つプロパティを取得できます。
[選択したビヘイビア]を設定しない場合、コンポーネント自体に設定されたプロパティを取得できます。
今回は、設定しません。
[選択したプロパティ]では、取得するプロパティを指定します。
[UserVariables::Product]を選択し、UserVariablesタブのProductを指定します。
[プロパティ名]では、Process#1内でのみ使用するプロパティの名前を定義できます。
「ProductNumber」に変更します。
入力された数値によって、生成される製品を変更します。
[Process#1]の[ステートメント]アイコンを選択します。
[フローコントロールステートメント]から[SWITCH CASE]を選択します。
SWITCH CASEステートメントは、変数、または数式の値に基づき、複数の処理の中から1つを選択して実行できます。
Switchを、GetPropertyの下にドラッグ＆ドロップし、移動させます。
[ステートメントプロパティ]ウィンドウの[コンディション]に、変数名、または数式を入力できます。
「ProductNumber」と入力します。
処理の選択肢を追加するため、Switchにカーソルを合わせ、表示される[+]アイコンを選択します。
Case<empty>が追加されたことがわかります。
Case<empty>を選択します。
[プロパティ]ウィンドウの[ケースコンディション]に、値、または数式を入力できます。
Switchのコンディションに入力した変数の値が、[ケースコンディション]と一致した場合、処理を実行します。
ProductNumberが1の場合、ブロックを生成するため、[ケースコンディション]に「1」と入力します。
「Create:Block」、「TransportOut:Block」をドラッグ＆ドロップし、Case 1に移動させます。
同様に、Caseを2つ追加します。
Case<empty>を選択します。
ProductNumberが2の場合、円柱を生成するため、[ケースコンディション]に「2」と入力します。
「Create:Cylinder」、「TransportOut:Cylinder」をドラッグ＆ドロップし、Case 2に移動させます。
本動画では設定しませんが、ケースコンディションには、「> 1」、「!= 1」、などの式を入力することも可能です。
数式の結果が、指定した値ではない場合の処理を設定します。
Case<empty>を選択します。
ProductNumberが1、または2でない場合、何も生成しないため、[ケースコンディション]に「default」と入力します。
製品を生成しないため、Case defaultの処理範囲には何も設定しません。
SWITCH CASEステートメント、またはIFステートメントの処理範囲に何も設定しない場合、注意が必要です。
今回は、Case defaultの処理が完了した時、Delay 3sを実行することができますが、実行する処理がない場合、エラーが発生します。
2つあるDelay 3sの内、1つを削除します。
シミュレーションを実行し、確認します。
「PM Global Variables」を選択します。
[コンポーネントプロパティ]ウィンドウを確認します。
「Product」の初期値は「0」であるため、製品を生成せず、待機していることがわかります。
「Product」を「1」に変更した場合、ブロックが、「2」に変更した場合、円柱が生成されることがわかります。
「PM Global Variables」に複数の変数を追加し、複数カ所のプロセスで、使用することが可能です。
複数のプロセスで使用している変数を、同時に確認することができます。
シミュレーションをリセットします。
eカタログのモデルを使用して、変数を作成する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

グローバルな変数を作ろう(2/2)

eカタログを用いたグローバルな変数を、プロセスから変更する方法（プロパティ取得、変数を割り当てる、プロパティコンディションを待機）
https://youtu.be/HVOrHlPcSAE
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_190_p2.zip

eカタログのモデルを使用して、グローバル変数を作成する方法について説明します。
パート1では、eカタログのモデルを使用して、変数を作成する方法を説明しました。
本動画では、製品を生成するたびに、その数をカウントし、別の地点ではその数を参照して製品を待機させる方法について説明します。
動画「グローバルな変数を作ろう(1/2)」の続きから設定します。
付属ファイル「PM Global Variables_after1.vcmx」を開きます。
シミュレーション実行中、ブロックを生成する時のみ、その数をカウントします。
整数型の変数を追加するため、PM Global Variablesを選択します。
[コンポーネントプロパティ]ウィンドウの[UserVariables]タブを表示します。
[Name]は、Count、[Type]は、Integerです。
[Define Variables]を選択し、変数を追加します。
[UserVariables]タブに、Countが追加されたことがわかります。
[プロセス]タブを開き、[エディタ]グループ-[プロセス]を選択することで、作業内容の確認と編集が可能です。
Process#1を選択します。
Process#1の[ステートメント]アイコンを選択し、追加可能なステートメントの一覧を表示します。
[その他のステートメント]から[プロパティ取得]を選択します。
プロパティ取得ステートメントは、シミュレーション開始前から、3Dワールドに存在するコンポーネントのプロパティを取得できます。
取得可能なプロパティは、ブール型、整数型、実数型、文字列型、ベクトル型、行列型の6種類です。
GetPropertyの下にドラッグ＆ドロップし、移動させます。
[ステートメントプロパティ]ウィンドウで、取得するプロパティを指定できます。
[選択したコンポーネント]では、コンポーネントを選択できます。
「PM Global Variables」を選択します。
[選択したビヘイビア]を設定することで、ビヘイビアが持つプロパティを取得できます。
[選択したビヘイビア]を設定しない場合、コンポーネント自体に設定されたプロパティを取得できます。
今回は、設定しません。
[選択したプロパティ]では、取得するプロパティを指定します。
[UserVariables::Count]を選択し、UserVariablesタブのCountを指定します。
[プロパティ名]では、Process#1内でのみ使用するプロパティの名前を定義できます。
「ProductCount」に変更します。
[プロセス]ウィンドウから「PM Global Variables」のプロパティの値を変更します。
[Process#1]の[ステートメント]アイコンを選択します。
[フローコントロールステートメント]から[変数を割り当てる]を選択します。
変数割り当てステートメントは、プロセス変数の値を設定できます。
「Assign <Null> = <Null>」を、Case1の「TransportOut: Block」の下にドラッグ＆ドロップし、移動させます。
[ステートメントプロパティ]ウィンドウの[ターゲットプロパティ]に、新しい値を代入する変数名を入力できます。
「ProductCount」と入力します。
[数式値]にCountに1を加算する式を定義します。
「ProductCount+1」と入力します。
[プロパティ]ウィンドウでカウントした値を[出力]ウィンドウに表示します。
[Process#1]の[ステートメント]アイコンを選択します。
[フローコントロールステートメント]から[プリント]を選択します。
[メッセージ]に「ProductCount」と入力することで、ProductCountの値を定義します。
シミュレーションを実行し、確認します。
[コンポーネントプロパティ]ウィンドウを確認します。
「Product」を「1」に変更した場合、ブロックが生成され、「2」に変更した場合、円柱が生成されます。
Countを確認すると、ブロックが生成された場合、プロパティの値を変更されていることがわかります。
また、[出力]ウィンドウを確認すると、ブロックをカウントした値が表示されていることもわかります。
シミュレーションをリセットします。
特定の条件や状態が満たされるまで、製品を待機させます。
Sinkを選択します。
ProductCountのプロパティを取得するため、Process#1のGetPropertyのUserVariables::Countをコピーし、Sinkに貼り付けます。
先頭にドラッグ＆ドロップし、移動させます。
ProductCountが5未満の場合は、次のステートメントに進まず、製品がコンベア上に5個以上に乗るまで待機させます。
[フローコントロールステートメント]から[プロパティコンディションを待機]を選択します。
プロパティコンディションを待機ステートメントは、変数が指定した値になるまで待機することができます。
GetPropertyの下にドラッグ＆ドロップし、移動させます。
[ステートメントプロパティ]ウィンドウの[変数名]に、変数名を定義します。
「ProductCount」と入力します。
[コンディション]は変数、または数式の値を入力できます。
「>=5」と入力することで、ProductCountが5以上であることを条件として設定します。
シミュレーションを実行し、確認します。
「PM Global Variables」を選択します。
[コンポーネントプロパティ]ウィンドウを確認します。
Productを1に変更した場合、ブロックが生成され、2に変更した場合、円柱が生成されます。
ProductCountが5未満の場合は、次のステートメントに進まず、ブロックが5個以上生成されるまで待機していることがわかります。
シミュレーションをリセットします。
製品を生成するたびに、その数をカウントし、別の地点ではその数を参照して製品を待機させる方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

コントローラとリソースの色をそろえよう

コントローラ（Human Transport Controllerなど）とリソース（Humanなど）の色をそろえる方法（ApplyColorToResources）
https://youtu.be/rHhPhRpg4JM
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_166.zip

コントローラーとリソースの色をそろえる方法について説明します。
リソースを制御する一部のコントローラーには、リソースの色を自動的にそろえる機能が備わっています。
付属ファイル「ResourceColor_before.vcmx」を開きます。
人とコントローラーが、2組配置されています。
「Human Transport Controller」を選択します。
[コンポーネントプロパティ]ウィンドウの[既定]タブ-[マテリアル]を変更することで、コンポーネントの色が変化します。
[light_green]を選択します。
3Dワールドのコントローラーが、緑色に変化したことがわかります。
[コンポーネントプロパティ]ウィンドウの[ApplyColorToResources]は、コントローラーとリソースの色をそろえる機能です。
[ApplyColorToResources]からチェックを外します。
コントローラーとリソースをインターフェースで接続し、色の変化を確認します。
[接続]グループの[インターフェース]を選択します。
[Human Transport Controller]の[Resources]を選択した状態で、[Human (Anna)]-[PMResource]の右側に表示されている丸をクリックします。
[インターフェースに接続]ウィンドウの[コンポーネント]を[Human Transport Controller#2]に変更し、以下のリストから[Human (Otto)]を選択することでも接続可能です。
右下の[閉じる]を選択し、[インターフェース]モードを解除します。
[ApplyColorToResources]にチェックが付いていないコントローラーと接続したAnnaの色は、変化していないことがわかります。
[ApplyColorToResources]にチェックが付いているコントローラーと接続したOttoは、コントローラーと同じ色に変化したことがわかります。
[ApplyColorToResources]は、AGVとフォークリフトのコントローラーにも存在します。
人と同様に、コントローラーとリソースをインターフェースで接続している場合、色をそろえることができます。
[ApplyColorToResources]は、リソース以外の色も自動的にそろえることができます。
eカタログの[タイプ別モデル]を展開し、[PM Navigation]を選択します。
[Idle Location]をダブルクリック、またはドラッグ＆ドロップし、3Dワールドに配置します。
Idle Locationは、同じコントローラーに接続されたリソースが、任意の時間以上、待機状態である場合、待機させておく場所です。
コントローラーとIdle Locationを接続します。
Ottoを制御しているコントローラーを選択します。
[コンポーネントプロパティ]ウィンドウの[Connect All Idle And Charging Locations]をクリックすることで、3Dワールドに存在する他のコントローラーと接続されていない全てのIdle、またはCharging Locationと一括で接続できます。
[出力]ウィンドウに、コントローラーと、Idle Locationが接続されたメッセージが表示されます。
3DワールドのIdle Locationが、コントローラーと同じ色に変化したことがわかります。
コントローラーの色を変更した時、接続されているリソース等にも変更が反映されます。
接続されているリソース等の色の変更は、コントローラーに反映されないため、注意が必要です。
[ApplyColorToResources]にチェックが付いている場合、データを保存し、開き直すと、コントローラーの色がリソースに反映されます。
コントローラーの色を変更することで、搬送経路をコントローラーごとに判別できます。
[プロセス]タブを開きます。
[エディタ]グループの[フロー]を選択することで、搬送経路を設定できます。
3Dワールドに表示された青い丸をプロセスノード、青い丸にカーソルを合わせると表示される名前をプロセスラベルと言います。
プロセスノードは、製品を搬送する経路の中継地点、プロセスラベルは中継地点の名前です。
3Dワールドと、[プロセスフローエディタ]ウィンドウに搬送経路を追加します。
Feederのプロセスラベルを、[プロセスフローエディタ]ウィンドウ、[フローグループ番号1]の[フローステップ]にドラッグ＆ドロップします。
同様に、Sinkのプロセスラベルを、Feederの右側に追加します。
3DワールドでAnnaを制御しているコントローラーのアイコンを選択します。
Feeder、Sinkの順にプロセスノードを選択します。
3Dワールドの何も配置されていない場所をクリックし、Sinkの選択を解除します。
Ottoを制御しているコントローラーのアイコンを選択します。
Feeder、Sinkの順にプロセスノードを選択します。
3Dワールドで2組のFeederとSinkの間に、色の異なるコントローラーのアイコンが表示されます。
コントローラーの色を変更することで、フローに表示されるアイコンの色も変化します。
シミュレーションを実行します。
AnnaとOttoは、担当の経路のみ搬送することがわかります。
シミュレーションをリセットします。
コントローラーとリソースの色をそろえる方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

コンベアの進行方向を変更しよう

進行方向の前進後退を変更できるコンベアを使用する方法（TwoWayConveyor）
https://youtu.be/Xe2cdJUvAHI
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_184.zip

進行方向の前進後退を変更できるコンベアの使用方法について説明します。
[eカタログ]ウィンドウ、[タイプ別モデル]-[Conveyors]-[Visual Components]からTwoWayConveyorを配置します。
ダブルクリックすることで、3Dワールドの原点に配置できます。
ドラッグ＆ドロップすることで、マウスボタンをはなした位置に配置できます。
TwoWayConveyorを選択することで、画面右側の[コンポーネントプロパティ]ウィンドウに、詳細な設定が表示されます。
[既定]タブを開きます。
[ConveyorLength]、[ConveyorWidth]、[ConveyorHeight]は、コンベアの長さ、幅、高さを変更できます。
[ConveyorSpeed]は、製品がコンベア上を移動する速度です。
[Presets]は、コンベアの見た目のテンプレートを選択できます。
[ShowRollers]は、ローラーの表示/非表示を変更できます。
[ShowBelts]は、ベルトの表示/非表示を変更できます。
[ShowGuideRails]は、ガイドレールの表示/非表示を変更できます。
[ShowSupport]は、支柱の表示/非表示を変更できます。
[ShowStartIdler]と[ShowEndIdler]は、コンベアの始端と終端にあるアイドラーの表示/非表示を変更できます。
[AutoProperties]を有効にすることで、接続先の、名前が一致するプロパティと、数値を統一させることができます。
[Direction]は、製品がコンベア上を移動する進行方向です。
[マニピュレーション]グループの[PnP]を選択した状態で、コンベアを選択すると、製品がコンベア上を移動する進行方向が三角形で表示されます。
Forwardの場合、三角形の頂点が指す方向に進み、Backwardの場合、Forwardと反対方向に進みます。
[TwoWayPath]タブは、コンベア上での製品の移動に関する設定です。
[既定]タブ-[Advanced]タブにも、同様の設定項目があります。
[TwoWayPath]タブを変更した場合、[既定]タブ-[Advanced]タブに反映されないため、[既定]タブ-[Advanced]タブを変更してください。
[Advanced]タブを開きます。
[ConveyorCapacity]は、コンベア上を移動できる製品の最大数です。
[Accumulate]は、製品がコンベア上で停滞した場合、移動し終わるまで、後続の製品を停止させるかを設定できます。
[SpaceUtilization]は、製品がコンベア上で停滞した場合、製品の隣接と、重複を変更できます。
[RetainOffset]は、コンベアに搬入する時の、製品の位置と、角度を保持するかを設定できます。
[SegmentSize]は、コンベア上の、製品と製品の間隔を変更できます。
[StructureWeight]は、支柱の幅を変更できます。
[RollerRadius]は、ローラーの半径、[RollerSpacing]は、ローラー同士の間隔です。
[BeltRollers]は、ベルトとローラーに、[NumberOfBelts]と[BeltSpacing]を反映させるかを設定できます。
[NumberOfBelts]は、ベルトの個数、[BeltSpacing]は、ベルト同士の間隔です。
[GuideRailHeight]は、ガイドレールの高さ、[GuideRailHeightOffset]は、コンベアとの距離、[GuideRailWidthOffset]は、幅を変更できます。
ガイドレールの幅は、コンベアの幅との差を入力します。
[NumberOfSupports]と[SingleLeg]で、支柱の本数を変更できます。
[SupportOffset]は、コンベアの始端、または終端から、支柱までの距離です。
[ExtraAxle]は、ローラーの軸の表示/非表示を変更できます。
[ProfileConstruction]は、支柱の見た目を簡易化できます。
[ConveyorStartOffset]と[ConveyorEndOffset]は、コンベアの接続位置を変更できます。
[Materials]タブは、コンベアの各パーツの色を変更できます。
シミュレーション中に、コンベアの進行方向を変更する方法について説明します。
付属ファイル「ChangeDirection.vcmx」を開きます。
製品の搬送経路を確認します。
[プロセス]タブを開きます。
[エディタ]グループの[フロー]を選択することで、製品の搬送経路を確認、編集できます。
3Dワールドに表示された青い丸をプロセスノード、青い丸にカーソルを合わせると表示される名前をプロセスラベルと言います。
プロセスノードは、製品を搬送する経路の中継地点、プロセスラベルは中継地点の名前です。
プロセスノード同士をつないでいる矢印をトランスポートリンク、矢印上のアイコンをTransport Controllerと言います。
トランスポートリンクは、製品の搬送経路、Transport Controllerは、搬送方法です。
[プロセスフローエディタ]ウィンドウでも、製品の搬送経路を確認できます。
製品は、Feederで生成され、Process#1まで空中を移動します。
Process#1から、Process#2、折り返し、Process#1までは、コンベア上を移動します。
Process#1から、Sinkまで空中を移動します。
中継地点での処理を確認します。
[エディタ]グループの[プロセス]を選択することで、中継地点で実行する処理を確認・編集できます。
Process#1と、Process#2を表示します。
Process#1では、製品の搬入と搬出を2回行います。
1回目は、Feederから搬入し、コンベアへ搬出します。
TransportInの[ソース]は前のプロセスから、TransportOutの[目的地]は[コンポーネントコンテナへ]です。
2回目は、コンベアから搬入し、Sinkへ搬出します。
TransportInの[ソース]はコンポーネントコンテナから、TransportOutの[目的地]は次のプロセスへです。
2回目のTransportInでは、1回目のTransportOutで搬出した製品を、再度、搬入するため、制限を掛けます。
[ステートメントプロパティ]ウィンドウの[製品フィルター]で、搬入する製品を制限できます。
[特定の製品]は、プロセス内のみで使用されている製品の名前で、製品を指定できます。
1回目に搬入した時、製品にProductInという名前を付与しています。
Sinkへ搬出した時、コンベアの進行方向は、Process#2からProcess#1の方向です。
2周目で、Feederから受け取った2個目の製品をProcess#1からProcess#2へ搬出するよう、コンベアの進行方向を変更するため、GetPropertyでTwoWayConveyorのDirectionを取得し、Assignで1周目の終了時のBackwardからForwardに変更しています。
「Forward」は文字列であるため、ダブルコーテーションで囲む必要があります。
ダブルコーテーション削除すると、文字列と認識されず、出力画面にエラーが表示されます。
Process#2では、製品をコンベアから搬入し、コンベアへ搬出します。
TransportInの[ソース]と、TransportOutの[目的地]は、共に[コンポーネントコンテナへ]です。
搬出前に、コンベアの進行方向を、Process#1からProcess#2の方向のForwardから、Process#2からProcess#1の方向のBackwardに変更しています。
Process#1と、Process#2のコンベアとの接続方法には、注意が必要です。
Process Nodeには、インターフェースという接続口が、3つあります。
[マニピュレーション]グループの[PnP]を選択し、Process Nodeを選択することで、確認できます。
三角形の頂点を右側に向けた時、一番右側から、ProcessNodeからの搬出用、コンベア接続用、搬入用インターフェースです。
コンベア側にも、コンベアからの搬出用、センサー接続用、搬入用インターフェースがあります。
Process Nodeの搬入用インターフェースは、コンベアの搬出用インターフェースとのみ、接続可能です。
Process Nodeのコンベア接続用インターフェースは、コンベアのセンサー接続用インターフェースとのみ接続可能です。
Process Nodeのコンベア接続用インターフェースで、コンベアを接続することでも、製品を搬入、搬出できますが、エラーが発生する場合があります。
Process Nodeのコンベアへの搬入、コンベアからの搬出が目的の場合、Process Nodeの搬入用、搬出用インターフェースで接続します。
Process#1は、一番右側のインターフェースで接続しています。
一度コンベアから搬出すると、別の中継地点を経由し、再度、コンベアに搬入する必要があります。
別の中継地点を経由しないため、Process#2は、真ん中のインターフェースで接続しています。
シミュレーションを実行します。
Feederから製品が生成され、コンベアまで移動します。
コンベアの始端から終端まで移動し、折り返していることがわかります。
コンベアの始端に到達し、Sinkへ移動しています。
シミュレーションをリセットします。
進行方向の前進後退を変更できるコンベアの使用方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

コンポーネント同士を接続してみよう

ワンウェイパス、ツーウェイパス、PnPについての説明
https://youtu.be/CynDP3z6OUE

本動画では、PnP機能について説明します。
PnP機能とは、プラグ&プレイのことで、コンポーネント同士を近づけた時に、インターフェースでコンポーネント同士を接続させる機能です。
PnP機能を使って、コンベアを接続させましょう。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Conveyors]から"Conveyor"を3Dワールド上にドラッグ&ドロップし、2つ配置します。
[マニピュレーション]-[PnP]をクリックして、「Conveyor」を選択します。
水色の円をドラッグすると、Z軸を固定して選択しているコンポーネントの向きを変更できます。
水色の円の内側をドラッグすると、選択しているコンポーネントを移動できます。
選択しているコンポーネントがPnP機能で接続ができる時、インターフェースが黄色の三角マークで表示されます。
「Conveyor」をドラッグして「Conveyor #2」に近づけると、「Conveyor」のインターフェースから「Conveyor #2」のインターフェースへ緑色の矢印が表示されます。
さらに近づけると、インターフェースが重なるように「Conveyor」が移動します。
PnP機能で接続した時、インターフェースの色が緑色に変わります。
PnP機能で接続する時は、インターフェースの向きを合わせる必要があります。
「Conveyor」と「Conveyor #2」の距離を離して、接続を解除します。
画面のように「Conveyor」の向きを変更して、再度「Conveyor #2」に近づけます。
インターフェースの向きが違うため緑色の矢印が表示されず、接続できません。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Conveyors]から"Turntable Conveyor"、[タイプ別モデル]-[Feeders]から"Basic Feeder"を3Dワールド上にドラッグ&ドロップします。
[マニピュレーション]-[PnP]を選択した状態で、「Basic Feeder」、「Conveyor」、「Turntable Conveyor」、「Conveyor #2」と順に接続します。
「Conveyor」のインターフェースと「Turntable Conveyor」のインターフェースは種類が異なります。
「Conveyor」のインターフェースのように、三角マークが1つのインターフェースは、ワンウェイインターフェースといいます。
ワンウェイインターフェース同士を接続する場合は、先ほど「Conveyor」を接続した時のように、インターフェースの向きを合わせる必要があります。
「Turntable Conveyor」のように、三角マークが2つのインターフェースは、ツーウェイインターフェースといいます。
コンポーネントの内側に向いている三角マークは、コンポーネント上へ製品を輸送する時の搬入口となるインターフェースです。
コンポーネントの外側に向いている三角マークは、コンポーネント上から製品を輸送する時の搬出口となるインターフェースです。
インターフェースを接続する時は、内側に向いているインターフェースと、外側に向いているインターフェースを近づけて接続します。
ツーウェイインターフェースは、内側を向いたインターフェースと、外側を向いたインターフェースの両方を含んだインターフェースです。
そのため、他のインターフェースを近づけた時、近づけた他のインターフェースの向きにあうインターフェースに、自動的に接続します。
「Conveyor #2」の接続を解除して、向きを反対にして「Conveyor #2」の別のインターフェースを「Turntable Conveyor」に近づけた場合も、接続できます。
「Conveyor #2」の接続する向きを、元に戻します。
シミュレーションを再生します。
「Basic Feeder」で生成された製品が、「Turntable Conveyor」を経由して「Conveyor #2」へ輸送されます。
インターフェースが接続されていない場合、製品は輸送されません。
[マニピュレーション]-[PnP]を選択した状態で「Conveyor #2」をドラッグして「Turntable Conveyor」から離し、「Turntable Conveyor」との接続を解除します。
[ホーム]タブ-[マニピュレーション]-[移動]をクリックします。
「Conveyor #2」をドラッグし、「Turntable Conveyor」に近づけます。
アタッチを使って、「Turntable Conveyor」と「Conveyor #2」を物理的に接続します。
「Conveyor #2」を選択した状態で[階層]-[アタッチ]をクリックし、「Turntable Conveyor」を選択してアタッチします。
[マニピュレーション]-[PnP]をクリックして、「Turntable Conveyor」をドラッグすると、アタッチした「Convyoer#2」も同様に移動します。
シミュレーションを再生します。
「Turntable Conveyor」と「Conveyor #2」はインターフェースで接続はされていません。
そのため、生成された製品は「Turntable Conveyor」で停止します。
次に、PnP機能を使って、ロボットにパーツを接続します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Robots]-[Visual Components]から「Generic Articulated Robot」、[タイプ別モデル]-[PM Transport Controllers]から「Robot Transport Controller」、[タイプ別モデル]-[Robot Positioners]から「Generic Servo Track」、[タイプ別モデル]-[Robot Tools]から「Parametric Box Gripper」を3Dワールド上にドラッグ&ドロップします。
[ホーム]タブ-[マニピュレーション]-[PnP]をクリックし、「Generic Articulated Robot」をドラッグして「Robot Transport Controller」に近づけ、接続します。
この時、「Robot Transport Controller」を親、「Generic Articulated Robot」は子として接続されます。
そのため、「Robot Transport Controller」をドラッグすると、「Generic Articulated Robot」も同時に移動します。
既に接続済みのコンポーネント同士の間に、コンポーネントを追加で接続したい場合は、一度コンポーネントの接続を解除する必要があります。
今回は、「Generic Articulated Robot」と「Robot Transport Controller」の間に「Generic Servo Track」を接続します。
「Generic Articulated Robot」をドラッグして「Robot Transport Controller」から距離を離し、接続を解除します。
「Generic Articulated Robot」をドラッグして「Generic Servo Track」の台座付近へ移動し、接続します。
「Generic Servo Track」をドラッグして「Robot Transport Controller」に近づけ、接続します。
これで、「Generic Articulated Robot」と「Generic Servo Track」と「Robot Transport Controller」を接続することができました。
"正射"モードについて説明します。
"正射"モードは、3Dワールドのオブジェクトの正投影表示のオン/オフを表示します。
正投影とは、立体的に表示されているものを平面的に表示するための手法の1つで、ものの形状や高さ/幅/奥行きを正確に表すことができます。
コンポーネント同士を近づけてもPnP機能で接続ができない場合、"正射"モードを切り替えることで改善される可能性があります。
以上で、「コンポーネント同士を接続してみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

コンポーネントの表示/非表示を切り替えよう

装置等のコンポーネントの表示/非表示を、プロパティやセルグラフから切り替える方法
https://youtu.be/Nh5-hWFxiV8

本動画では、コンポーネントの表示/非表示の設定について説明します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Layouts]から"Machine Tending"をダブルクリックします。
適当なコンポーネントをクリックします。
[コンポーネントプロパティ]-[既定]タブの"表示"プロパティは、コンポーネントの表示/非表示を切り替えます。
非表示のコンポーネントは、3Dワールド上で選択できなくなります。
非表示のコンポーネントを再表示する場合、いまチェックを外した"表示"プロパティを再度チェックすることで行えますが、[セルグラフ]ウィンドウでも行うことができます。
[セルグラフ]ウィンドウを表示します。
[セルグラフ]ウィンドウのプロパティについて説明します。
コンポーネント名の横にある目のアイコンをクリックすると、コンポーネントの表示/非表示が切り替えられます。
[セルグラフ]ウィンドウでは、コンポーネントはカテゴライズされており、フォルダーで分けられています。
フォルダーの横にも目のアイコンがあり、クリックすると、そのフォルダーに含まれているすべてのコンポーネントをまとめて表示/非表示を切り替えることができます。
[セルグラフ]ウィンドウ上部の検索欄の横の目のアイコン-"隠しコンポーネントを表示"をクリックすると、非表示になっているコンポーネントを白色で表示します。
以上で、「コンポーネントの表示/非表示を切り替えよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

サイクルタイムを測定してみよう

マシン、ロボット、作業工程のサイクルタイムを測定する方法（Cycle Time (Signals)）
https://youtu.be/tVFr6Zsi8ME

本動画では、eカタログのコンポーネントを使って、サイクルタイムを測定する方法について説明します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Layouts]から"Machine Tending"をダブルクリックします。
このレイアウトにコンポーネントを追加して、マシンのサイクルタイムを測定します。
[タイプ別モデル]-[Statistics]から「Cycle Time (Signals)」を3Dワールドにドラッグ&ドロップします。
「Cycle Time (Signals)」は、シグナル接続することでサイクルタイムが測定できるコンポーネントです。
3Dワールドのコンポーネント上のノートをクリックすると、使用方法が確認できます。
1.サイクルタイムを測定したいコンポーネントのBoolean型のシグナルと接続します。
2.シグナルにTrueをトリガーすることでサイクル開始時刻を表示して測定を開始します。
Falseをトリガーすることで、測定を停止できます。
3.サイクルタイムについては[出力]ウィンドウ、統計情報についてはコンポーネントプロパティから参照します。
マシンのサイクルタイムを測定するために、「CycleTime(Signals)」とマシンをシグナル接続します。
[ホーム]タブ-[接続]-[シグナル]をクリックします。
[シグナルを接続]ウィンドウ-[コンポーネント]に「Cycle Time (Signals)」が設定されていることを確認します。
"In 0"を選択し、"コネクション"に"Process Machine - ProLathe"と"TransSignal"を設定します。
"TransSignal"は、マシンに製品を搬入した、またはマシンから製品が搬出したことを通知するシグナルです。
続けて、"シグナルを接続"の"In 1"を選択し、"コネクション"に"Process Machine – ProLathe #2"と"TransSignal"を設定します。
[接続]-[シグナル]を再度クリックして"シグナルを接続"を閉じます。
シミュレーションを再生します。
サイクルタイムが計測され、[出力]ウィンドウに表示されます。
また、"Cycle Time"をクリックして[コンポーネントプロパティ]ウィンドウ-[CycleTimes]タブをクリックします。
直近のサイクルタイム、最大のサイクルタイム(_max)、最小のサイクルタイム(_min)を確認できます。
これで、マシンのサイクルタイムの測定ができました。
次に、ロボットのサイクルタイムを測定します。
レイアウトを削除します。
[出力]ウィンドウも初期化してください。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Layouts]から"Spotwelding BiW"をクリックします。
[タイプ別モデル]-[Statistics]から「Cycle Time (Signals)」を3Dワールド上にドラッグ&ドロップします。
サイクルタイムを測定するために、「Cycle Time (Signals)」とロボットをシグナル接続します。
[ホーム]タブ-[接続]-[シグナル]をクリックします。
[シグナルを接続]ウィンドウで"In 0"が選択された状態で、"コネクション"に"KR 120 R2500 pro"と"OutPuts 100"を設定します。
続けて、"シグナルを接続"の"In 1"を選択し、"コネクション"に"KR 120 R2500 pro #2"と"OutPuts 100"を設定します。
"In 1"の設定と同様の手順で"In 2"、"In 3"、"In 4"も設定を行います。
[接続]-[シグナル]を再度クリックしてウィンドウを閉じ、シミュレーションを再生します。
ロボットがシグナルを送信しないので、サイクルタイムは測定されません。
各ロボットが作業を開始する前と完了した後にシグナルを送信するように変更して、サイクルタイムが測定できるようにします。
[プログラム]タブに移動します。
3Dワールド上の台座の上に配置されたロボット(KR 120 R2500 Pro)を選択し、[プログラムエディタ]ウィンドウ-"hold"をクリックします。
先頭に"セットバイナリ出力ステートメント"を追加します。
追加された"Set OUT~"を選択します。
[ステートメントプロパティ]ウィンドウから"バイナリ出力ステートメント"を"100"、"出力値"にチェックを入れます。
最終行にも"セットバイナリ出力ステートメント"を追加します。
追加された"Set OUT~"を選択し、[ステートメントプロパティ]ウィンドウから"バイナリ出力ステートメント"を"100"に変更します。
出力値はチェックが外れたままにします。
これで、"hold"ルーチンを実行した時にサイクルタイムの測定が開始され、終了直前に測定を終了するようになりました。
別のロボットを選択します。
"weld"ルーチンにも、先ほどと同様の手順で先頭に"Set Out[100]=True"、と最終行に"Set Out[100]=False"を追加します。
こちらの場合は、"weld"ルーチンを実行した時にサイクルタイムの測定が開始され、終了直前に測定を終了するようになります。
全てのロボットのルーチンに追加したら、[ホーム]タブをクリックします。
3Dワールド上の「Cycle Time」を選択して、[コンポーネントプロパティ]ウィンドウ-[CycleTimes]タブをクリックします。
シミュレーションを再生します。
各ロボットがシグナルを送信するようになったため、サイクルタイムが計測できるようになりました。
以上で、「サイクルタイムを測定してみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

シグナルがトリガーされるまでプロセスの実行を待機させよう

シグナルが指定の値になるまでプロセスの実行を待機させる方法（シグナル待機）
https://youtu.be/ID68ClFODRo
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_126.zip

本動画では、"シグナル待機"ステートメントを使って、プロセスの実行タイミングを制御する方法を説明します。
初めに、[インポート]-[ジオメトリ]をクリックし、MachineBody.SLDPRTをインポートします。
[モデルをインポート]ウィンドウから、"含める"は"マテリアル"のみにチェック、"フィーチャツリー"を"最小化"、"上軸"を"+Z"に変更して[インポート]をクリックします。
[モデリング]タブに移動します。
インポートした時点では、モデルは1つのフィーチャとして最小化した状態になっています。
例えば、インタラクティブ機能を使って一部分だけを動かすなどはできず、移動する時は全てのフィーチャがまとまって移動します。
そのため、インポートしたモデルを一度細分化して、可動部分を設定しなおします。
「MachineBody」をクリックします。
[コンポーネントグラフ]ウィンドウ-"Root"-"Collapsed_0"を右クリックし、"エクスプロード"をクリックします。
"Collapsed_0"が"Collapsed_0_1"に変更されます。
"Collapsed_0_1"を展開すると、分解された50個のフィーチャを確認できます。
次に、"Collapsed_0_1"下の"Collapsed_0_3"と"Collapsed_0_4"を選択した状態で右クリックし、"抽出リンク"をクリックします。
[リンクプロパティ]ウィンドウから[JointType]を「直進」に変更し、[軸]を「+X」に設定します。
[ジョイントプロパティ]の"Controller"を"新規サーボコントローラ"に変更し、[最小リミット]を"0"、[最大リミット]を"550"に設定します。
[マニピュレーション]-[インタラクティブ]を選択し、[コンポーネントグラフ]の"Link_1"を選択すると、3Dワールドの該当部分がドラッグできるようになっています。
続いて、"シグナル待機"ステートメントの設定を行います。
まず、モデルにシグナルを追加します。
[コンポーネントグラフ]-"MachineBody"を選択した状態で"動作設定"-"ビヘイビア"から"ブール型シグナル"と"プロセスエグゼキュータ"をクリックします。
"プロセスエグゼキュータ"を追加することで、モデルにプロセスを設定できるようになります。
次に、[プロセス]タブに移動します。
[エディタ]-[プロセス]を選択し、「MachineBody」上の青色のアイコンをクリックします。
"新規プロセスルーチンをクリックすると、プロセスが追加され、ステートメントが追加できるようになります。
"ステートメント"-"シグナル待機"をクリックします。
"WaitSignal:~"を選択した状態で[ステートメントプロパティ]から"コンポーネント"に"MachineBody"、"シグナル"に"BooleanSignal"を設定します。
さらに[コンディション]に"True"、"タイムアウト"に"10"を設定します。
これで、「MachineBody」の"BooleanSignal"が"True"になるまで待機するステートメントが記述できました。
"タイムアウト"はトリガー待機を行う時間であり、"タイムアウト"秒経過してもシグナルを受信しなかった場合は、次のステートメントに移ります。
"タイムアウト"が0の場合、[コンディション]のシグナルを受信するまでずっと待機します。
次に、シグナルを受信した後に開閉を行うステートメントを追加します。
"ジョイントを移動"ステートメントは、ジョイントを設定して、ジョイントをターゲット値まで移動させるステートメントです。
"ステートメント"-"ジョイントを移動"をクリックします。
"コントローラ"を"サーボコントローラ"、"ジョイント"を"J1"、"ターゲット値"を"550"に変更します。
これで、シグナルを受信して「MachineBody」を動かすステートメントが設定できました。
シグナルを受信して、閉じるステートメントを追加します。
"WaitSignal:~"と"MoveJoint:~"を選択してコピー＆ペーストします。
追加された"WaitSignal~"をクリックします。
[ステートメントプロパティ]ウィンドウから、[コンディション]を"False"、"MoveJoint:～"の"ターゲット値"を"0"にします
これで、シグナルの受信で開閉を行うようにできました。
[ホーム]タブ-[接続]-[シグナル]をクリックし、"MachineBody"を選択した状態でシミュレーションを実行します。
"BooleanSignal"の"True/False"を切り替えると、マシンの扉が開閉するようになりました。
以上で、「シグナルがトリガーされるまでプロセスの実行を待機させよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

シグナルを使ってコンベアを制御しよう

プロセスから、コンベアのシグナルを使用して稼働を制御する方法
https://youtu.be/mgVV6EMJ5ws
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_097.zip

本動画では、シグナルを使ってコンベアの稼働/停止を制御する方法を説明します。
まず初めに、レイアウトを作成します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Flow Components]から、"Feeder Process"と"Process Node"を3Dワールド上にドラッグ&ドロップします。
[タイプ別モデル]-[Conveyors]-[Visual Components]から"Conveyor"を3Dワールド上にドラッグ&ドロップします。
「Conveyor」をコピー&ペーストで合計3つにします。
[マニピュレーション]-[PnP]を選択した状態で「Feeder Process」をドラッグして「Conveyor」の端に近づけ、接続します。
「Conveyor #2」をドラッグして「Conveyor」に近づけ、接続します。
「Process Node」をドラッグして「Conveyor #2」に近づけ、接続します。
「Conveyor #3」をドラッグして「Process Node」に近づけ、接続します。
次に、プロセスを編集します。
[プロセス]タブ-[エディタ]-[プロセス]を選択し、"Feeder"をクリックします。
"TransportOut:~"を選択し、[ステートメントプロパティ]ウィンドウから[目的地]を「コンポーネントコンテナへ」に変更します。
"Process #1"をクリックします。
"TransportIn:~"を選択し、[ステートメントプロパティ]ウィンドウから"ソース"を"コンポーネントコンテナから"に変更します。
"TransportOut:~"を選択し、[ステートメントプロパティ]ウィンドウから[目的地]を"コンポーネントコンテナへ"に変更します。
"ステートメント"から"ディレイ"を追加し、"TransportIn:~"と"TransportOut:~"の間に配置して、[ステートメントプロパティ]ウィンドウから"分布"を"5"に変更します
シミュレーションを再生します。
「Conveyor」上の製品が「Process Node」上に到達すると5秒停止するようになります。
これで、レイアウトを作成できました。
シグナルでコンベアの稼働/停止を制御するようにします。
まず、「Process #1」にシグナルを送信するステートメントを追加します。
「Process #1」をクリックします。
"TransportIn:~"を選択した状態で"ステートメント"-"シグナル送信"をクリックします。
"シグナル送信"ステートメントは、指定したコンポーネントのシグナルに値を送信するステートメントです。
追加された"SendSignal:~"をクリックして、[ステートメントプロパティ]ウィンドウから"コンポーネント"に"Conveyor #3"、"シグナル"に"PowerOnSignal"、"値"に"False"を設定します。
"PowerOnSignal"は、「Conveyor」の稼働・停止を制御するシグナルです。
"True"の場合は稼働中、"False"の場合は停止中になります。
"SendSignal:~"を選択した状態でコピーし、"Delay"と"TransportOut:~"の間にペーストします。
ペーストした"SendSignal:~"をクリックし、[ステートメントプロパティ]ウィンドウから"値"を"True"に変更します。
これで、「Process #1」に製品が搬入されるとシグナルが送信され、「Conveyor #3」の稼働・停止が切り替わるようになりました。
複数の「Conveyor」を同時に稼働・停止を切り替えられるように設定を変更します。
[ホーム]タブ-[接続]-[シグナル]をクリックします。
いずれかの「Conveyorクリックすると、各「Conveyor」のシグナルが表示されます。
"PowerOnSignal"を"Conveyor-Conveyor #2-Conveyor #3"の順に接続します。
シグナル接続をすることで、いずれかのシグナルの値が変わると、接続している他のシグナルも同様に変わるようになります。
これで、複数の「Conveyor」を「Process #1」で同時に稼働・停止を切り替えられるようになりました。
シミュレーションを再生します。
「Process Node」に製品が搬入されると、各「Conveyor」が停止をするようになります。
「Process Node」では、1.製品を搬入する 2.「Conveyor #3」の"PowerOnSignal"に"False"シグナルを送信、シグナルを受信した「Conveyor #3」と、シグナルを接続している他の「Conveyor」が停止 3.5秒間プロセスが停止 4.「Conveyor #3」の"PowerOnSignal"に"True"を送信、シグナルを受信した「Conveyor #3」と、シグナルを接続している他の「Conveyor」が稼働 5.製品を搬出する、という処理が、製品を搬入するたびに行われます。
以上で、「シグナルを使ってコンベアを制御しよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

シミュレーション中に製品を生成しよう（1/10）

シミュレーション中に製品を生成する、Basic Feederの使い方
https://youtu.be/_V3hz2tTMsA

Geminiには、Feederと呼ばれる製品を生成する装置があります。
Feederを使うことで、シミュレーション中に加工などの対象になる製品を生成することができます。
本動画では、Basic Feederを使って、Feederの使い方と設定方法について説明します。
初めに、[eカタログ]-[タイプ別モデル]-[Feeders]-[Visual Components]をクリックします。
全10回にわたって、ここに表示されている9つと、"PM Flow Components"の2つの計11個のFeederを紹介します。
"Basic Feeder"は、ここに表示されている9つのFeederの中で最もシンプルなFeederです。
まず、Feederの基礎的な使い方を、このBasic Feederを使って説明します。
"Basic Feeder"を3Dワールドにドラッグ＆ドロップします。
シミュレーションを実行します。
"3Dワールドツールバー"の"フレームタイプ"をクリックします。
Feederは基本的に、定義されたパーツを"Create"フレームで生成し、"Out"フレームへ流します。
そのため、Feederを使う際は、パーツを流す方向にコンベアを接続することが多いです。
[eカタログ]-[タイプ別モデル]-[Conveyors]-[Visual Components]をクリックします。
"Conveyor"を3Dワールドにドラッグ＆ドロップし、「Basic Feeder」と「Conveyor」をPnPで接続します。
シミュレーションを実行すると、「Basic Feeder」で生成されたパーツがコンベア上を流れます。
次に、Feederのプロパティについて説明します。
3Dワールドの「Basic Feeder」を選択し、[コンポーネントプロパティ]を開きます。
"ConveyorLength/Width/Height"を変更すると、Feederのサイズを変更することができます。
「Conveyor」をPnPでFeederと接続しなおすと、接続した"ConveyorWidth"と"ConveyorHeight"はFeederと同値になります。
生成するパーツの定義は、Feederによって異なります。
"Basic Feeder"では、VCIDを入力するか三点リーダーをクリックしてファイルを直接指定することで定義できます。
生成するパーツについて、"ブロッキング最適化"と"パーツプーリング"の有無を設定できます。
"ブロッキング最適化"を有効にすると、コンポーネントを作成するクリエイターに最適化を行い、シミュレーションのパフォーマンス向上につながります。
"パーツプーリング"は、シミュレーション中に削除された動的コンポーネントを、新しいコンポーネントを作るために再循環させます。
そのため、パーツを生成するためのメモリの削減につながります。
シミュレーション中に[マテリアル]などのプロパティを変更する場合があるかもしれません。
その場合、その変更がされた状態でコンポーネントが再利用されてしまうため、パーツプーリングを設定する際は注意が必要です。
また、パーツを定義する際にプロパティ値に"ProdID"を設定するFeederがあります。
"ProdID"は、パーツを番号で管理するときなどに使用されます。
"Interval"は一度パーツを生成した後、次のパーツを生成するまでの時間です。
画面では、"Interval"を"0"に変更したため、製品が連続して生成されています。
また、"Limit"はシミュレーション実行中に生成できるパーツの上限数です。
この2つの設定は、Feederによって別のタブや別の名称で定義する、もしくは定義しないことがあります。
次に、[OutPath]タブに移動します。
"容量"は、Feederの上に同時に置くことができるパーツの上限数のことです。
容量を変更したら、[既定]タブの"Limit"を100に戻してシミュレーションを実行します。
Feeder上に流れるパーツの数が変化しました。
"速度"は、パーツがFeeder上を流れる速さです。
画面では、"速度"を"1000"に変更したため、Feeder上の移動速度が速くなりました。
"セグメントサイズ"は、パスのセグメントの長さを定義します。
セグメントとは、パスの直線距離をセグメントサイズごとで区切った時の1区間のことです。
現在のパスの直線距は500なので、値を"100"と設定した場合、セグメントは5個生成されます。
設定すると、セグメント間でのコンポーネントの移動を制限します。
セグメントが1つしか生成されない場合、制限はされません。
"スペース使用"は、初期設定では有効になっており、パス上にあるコンポーネント同士が重ならなくなっています。
この設定を無効にすると、生成されたコンポーネント同士が重なるようになります。
以上で、Basic Feederを使ったFeederの使い方と設定方法の説明を終わります。
ご視聴ありがとうございました。

=================================================================================

シミュレーション中に製品を生成しよう（2/10）

シミュレーション中に製品を生成する、PM Flow Componentsの2種の使い方
https://youtu.be/RogNhhhSBLw

本動画では、プロセスフローを作成する時に使用するFeeder ProcessとFeederについて説明します。
[eカタログ]-[タイプ別モデル]-[PM Flow Components]に移動します。
[eカタログ]から"Feeder Process"を3Dワールドにドラッグ&ドロップします。
「Basic Feeder」は使用しないため削除し、フレームも一度非表示にします。
「Feeder Process」と「Conveyor」をPnPで接続します。
"Feeder Process"は、初期設定のままコンベアに接続しても、生成したパーツは流れません。
パーツの輸送先として、ほかのプロセスを追加する必要があります。
今回は、"Sink Process"を使用します。
[eカタログ]から"Sink Process"を3Dワールドにドラッグ&ドロップし、コンベアと接続します。
[プロセス]タブの[フロー]を選択して"Feeder"-"Sink"のフローを作成します。
パーツを流すフィーダーのステートメント文"TransportOut"の[目的地]と、受け取る"Sink Process"の"TransportIn"の"ソース"は一致させなければいけません。
シミュレーションを実行すると、パーツがコンベア上を流れるようになりました。
[エディタ]-[フロー]（製品）をクリックし、[製品タイプエディタ]を開きます。
"Feeder Process"で生成するパーツは、"製品タイプエディタ"でフローごとに管理されています。
そのため、そのフローで定義されていないパーツを生成しても、基本的には輸送されません。
試しに、フローグループを追加して、"フローグループ番号1"のプロセスフローを削除します。
"フローグループ番号2"に、先ほどのように"Feeder"-"Sink"のプロセスフローを作成します。
シミュレーションを実行しても、プロセスフローに製品が定義されていないため、製品はコンベア上を流れません。
フローグループを元に戻します。
[ホーム]タブをクリックし、3Dワールド上の「Feeder Process」を選択します。
生成するパーツは、[コンポーネントプロパティ]ウィンドウの[ProductCreator]タブの"パーツ"から選択ができます。
"間隔"はBasic Feederの時に説明した"Interval"、"制限"は"Limit"と同じ設定です。
実際にパーツを定義してみましょう。
[eカタログ]-[タイプ別モデル]-[Products and Containers]-[Visual Components]をクリックします。
"Box"を3Dワールドにドラッグ&ドロップします。
[プロセス]タブに移動し、[製品タイプエディタ]で"フローグループ番号1"を選択した状態で、"製品の定義"-"製品タイプの追加"をクリックします。
追加した"製品タイプ番号1"を選択し、[プロパティ]ウィンドウ-[Name]を"Box"に変更します。
"コンポーネントURI"のマウスカーソルのアイコンをクリックし、3Dワールドの「Box」をクリックします。
「Feeder Process」をクリックし、"ProductCreator"の"パーツ"をクリックすると、"Box"がリストに追加されているため選択します。
シミュレーションを実行すると、Boxが生成されます。
プロセスモデリングでは、コンベア以外の方法でもパーツの運搬が行えます。
[eカタログ]-[タイプ別モデル]をクリックし検索欄に"Human"を入力します。
"Human"と"Human Transport Controller"を3Dワールドにドラッグ&ドロップします。
"Feeder Process"と"Sink Process"を"Conveyor"から離します。
[プロセス]タブ-[エディタ]-[フロー]を選択し、"Human Transport Controller"のひし形をクリックします。
"Feeder"-"Sink"プロセスを右クリックし、"トランスポートコントローラを変更"をクリックします。
[ホーム]タブ-[接続]-[インターフェース]をクリックし、"Human-PMResource"と"Human Transport Controller-Resources"を接続します。
シミュレーションを実行すると、「Human」がパーツを輸送するようになります。
「Feeder Process」をクリックし、[ProductCreator]タブに移動します。
[ProductCreator]タブの"フィードモード"では、Feederがパーツを生成するときのルールを設定できます。
初期設定の"単一"は、1種類のパーツのみを生成します。
"バッチ"は、複数のパーツをバッチ間隔秒のインターバルを挟んで生成することができます。
生成するパーツの数やインターバルは個別に設定でき、ループを有効にすることで生成し続けるようにもできます。
"Count"はパーツの生成数、"Interval"は同じパーツを生成する時のインターバルを設定します。
画面の設定では、"Boxをインターバル1秒で2個生成"と"VC Canをインターバル1秒で3個生成"を"バッチ間隔1秒"を挟みながら繰り返しています。
"表"はエクセルファイルを使って、生成するパーツとインターバルを設定することができます。
読みこめるファイル形式はxlsです。
入力形式は1列目が製品名、2列目がインターバルです。入力する時に余分な空白は入力しないでください。
"分布"は、製品に"Propability"を設定してパーツに出現率を設定することができます。
各Productの出現率は、そのProductのPropability/Propabilityの総和になります。
画面では、Boxの出現率が1/10、VC_Canの出現率は9/10となります。
次に、[既定]タブについて説明します。
"IconWidth"は、「Feeder Process」のアイコンの大きさを変更します。
[ResourceApproach]と[ResourceOffset]は、"ResourceLocation"というリソースがパーツを受け取る時の位置の設定になります。
"Resource Approach"は、選択した向きになるように、[ResourceOffset]の角度を変更します。
画面では"Resource Approach"を変更したため、リソースがパーツを受け取る時の向きが変わりました。
"ResourseOffset"は、"ResourceLocation"の位置を設定します。
画面では、値を変更したことで「Feeder Process」と重なる位置でパーツを受け取っています。
"ShowResourceLocation"は、"ResourceLocation"の表示/非表示、"ShowGeo"は「Feeder Process」のジオメトリの表示/非表示を設定します。
非表示にした場合でも、シミュレーション実行時にはパーツは生成されます。
"ShowWhenSimulating"は、シミュレーション実行中、"ShowWhenPaused"は、停止中の時の「Feeder Process」のジオメトリの表示/非表示を設定します。
"Center On Path"は、コンポーネントに接続している場合、その真ん中に移動する機能です。
実際の動作は"Feeder Point"の時に紹介します。
"AutoProperties"は、プロパティ値が接続したコンポーネントによって自動的に変更する機能です。
[eカタログ]から「Conveyor」を3Dワールド上にドラッグ&ドロップして「Feeder Process」とPnPで接続します。
画面では、この機能を有効にすると「Feeder Process」の、"ConveyorHeight"が接続したコンベアの値に変更されているのがわかります。
「Feeder Process」と「Conveyor」を切り離して、「Conveyor」を削除します。
"TriggerAt"と"ResetAt"は、コンポーネントを検出するセンサーモードの設定を行います。
Feeder Process自体にはコンポーネントが流れてくることがあまりなく、センサーモードを使うことは基本的にありません。
詳しい説明はプロセスモデリングの説明時に行います。
次に 、"Feeder"の説明をします。
"PM Flow Components"に移動して、"Feeder"を3Dワールドにドラッグ&ドロップします。
"Feeder"は、"Basic Feeder"のように"Conveyor"などに接続して使用します。
「Feeder」と「Conveyor」をPnPで接続します。
シミュレーションを実行すると、初期設定の"VC_Cylinder"がコンベアに流れます。
パーツの定義は"Feeder Process"と同じですが、"Feeder"はプロセスを持たないため他のコンポーネントでも問題なく生成してコンベアに流すことができます。
[既定]タブと[ProductCreator]タブは「Feeder Process」の内容と、[Path]タブは「Basic Feeder」の[OnPath]（OutPath）タブの内容と同じです。
[PartPosition]タブはパーツを生成する位置の設定が行えます。
"RandomOffset"でオフセットの範囲を設定し、"RandomOffsetEnabled"を有効にすることで、生成するパーツの位置がランダムに変更されます。
"RandomTurn"で角度の範囲を設定し、"RandomTurnEnabled"を有効にすることで、生成するパーツの向きが変更されます。
以上で、Feeder ProcessとFeederの説明を終わります。
ご視聴ありがとうございました。

=================================================================================

シミュレーション中に製品を生成しよう（3/10）

シミュレーション中に製品を生成する、Advanced Feederの使い方
https://youtu.be/raiFDxqJ2Gw

本動画では、"Advanced Feeder"について説明します。
初めに、[eカタログ]-[タイプ別モデル]-[Feeders]-[Visual Components]をクリックします。
"Advanced Feeder"を3Dワールド上にドラッグ&ドロップします。
元々接続していたFeederを削除し、「Advanced Feeder」と「Conveyor」をPnPで接続します。
"Advanced Feeder"は、1つのコンポーネントから複数の種類のパーツを生成できるフィーダーです。
シミュレーションを実行すると、ランダムに三種類のパーツが生成されます。
初期設定では3つのパーツが[コンポーネントプロパティ]ウィンドウの[TemplateComponents]タブで定義されています。
"Advanced Feeder"のプロパティについて説明します。
[既定]タブをクリックします。
"CSV Delimiter"は、[BatchBook]タブや[DistributionBook]タブでcsvファイルを読み込む際の、区切り記号を設定します。
"WarmupDelay"は、最初のパーツが生成されるまでの時間を設定します。画面では、最初のパーツが生成されるまで5秒かかるようになりました。
"CreationMode"は、生成に使用する設定を"Batch"もしくは"Distribution"から選択します。
"Distribution"を選択した場合は、"CreationInterval"で次のパーツを生成するまでの時間が設定できます。
画面では、インターバルを0や5に変更して実行しています。
"Batch"を選択した場合は、"LoopBatches"を有効にすると生成し続けるようになります。
"CreationMode"の2種の設定は、各タブの"エディタで開く"をクリックすると、エディタでファイルが開き、内容を確認できます。
これをエディタで編集する、もしくは各タブの"Read ~ from CSV-file"からcsvファイルを読み込むことで設定を変更することができます。
また、"Set Default Book"で初期設定に戻すこともできます。
設定内容について説明します。
"BatchBook"と"DistributionBook"は、値をカンマ記号で区切ることで定義します。
"BatchBook"の設定内容は左から、生成数、生成間のインターバル、生成したコンポーネントのProdID、コンポーネントの色、生成するコンポーネントの[TemplateComponents]タブでの番号、"BatchSize"分生成した後に次の製品タイプを生成するまでの時間となります。
"CustomProperty"は、値の入力で型名がどうなるかの入力例として記述されており、シミュレーションに影響しません。
"CustomProp1"のようにコンマで区切った数値は浮動小数点を扱うreal型、"CustomProp2"のように単に数値の場合は整数を扱うint型、"CustomProp3"のようにコーテーションマークで囲った場合は文字列を扱うstring型になります。
"Batch"モードはループが無効の場合、最終行まで実行すると、以降パーツは生成されなくなります。
"DistributionBook"に移動します。
"BatchBook"のものと同名のものは、設定内容も同じです。
"Propability"は、個別のパーツに対して生成する確率を設定します。
そのため、この値の総和は100になる必要があります。
"Distribution"モードは、生成するコンポーネントを確率で決定し生成しつづけます。
実際に新しいコンポーネントを追加して、各モードで生成できるようにしてみましょう。
まず、[コンポーネントプロパティ]ウィンドウ-[TemplateComponents]タブに移動、"Add TemplateComponent"をクリックします。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Products and Containers]をクリックします。
"Box"を右クリックして、"メタデータを表示"をクリックします。
"VCID"をコピーして、"閉じる"をクリックします。
[コンポーネントプロパティ]ウィンドウ-[TemplateComponents]タブから、"Component4::パーツ"に"vcid:"を入力し、先ほどメタデータでコピーしたVCIDをペーストします。
各ノートに追記していきます。
新しい製品タイプの各プロパティを、カンマ区切りで設定します。
各"CustomProp"は、空欄だとエラーが出力するので、任意の値を入れてください。
"Propability"の総和が100になるように、他の"Propability"を変更します。
"BatchBook"も、同様に製品タイプを定義します。
これで、パーツ4を使った製品タイプを、"BatchBook"と"DistributionBook"に追加できました。
シミュレーションを実行すると、青色のBoxが生成されるようになりました。
[PartPosition]タブは、"Feeder"同様生成するパーツの位置を設定できます。
オフセットと角度に加え、生成する位置の原点の設定も行うことができます。
以上で、Advanced Feederの説明を終わります。
ご視聴ありがとうございました。

=================================================================================

シミュレーション中に製品を生成しよう（4/10）

シミュレーション中に製品を生成する、Shape Feederの使い方
https://youtu.be/ixECDfMC-Ss

本動画では、Shape Feederについて説明します。
初めに、[eカタログ]-[タイプ別モデル]-[Feeders]-[Visual Components]をクリックします。
「Shape Feeder」を3Dワールド上にドラッグ&ドロップします。
元々接続していたフィーダーを削除して、「Shape Feeder」と「Conveyor」をPnPで接続します。
シミュレーションを実行すると、Visual Components Boxが生成されます。
"Shape Feeder"は、生成するコンポーネントのサイズや位置、オフセットなどを詳細にタブから設定することができます。
[既定]タブのプロパティから説明します。
"Product"は、生成するコンポーネントをリストボックスから選択することで変更できます。
画面では、"Product"を"CollarPallet"や"Bottle"に変更しています。
"CreateOnlyOnSignal"を有効にすると、シグナルを受信したときのみパーツを生成するようになります。
"CreateOnlyOnSignal"を有効にしたら、シミュレーションを実行します。
この状態ではパーツは生成されないので、[ホーム]タブ-[シグナル]をクリックします。
"CreateSignal"横のオレンジ色の丸をクリックするとシグナルが「Shape Feeder」に送信され、シグナルを受信したフィーダーはコンポーネントを生成します。
[接続]タブ-[シグナル]をクリックし、[シグナルを接続]ウィンドウを閉じます。
[コンポーネントプロパティ]ウィンドウの[既定]タブに戻り、"CreateOnlyOnSignal"を無効に戻します。
"StationaryCreator"は生成したコンポーネントをフィーダーに固定します。
"ShowMessages"を有効にすると、設定ミスのエラーを起こした際に出力エラーが表示されます。詳細な設定は、PythonScriptに記述されています。
"Product"で選択しているコンポーネントの定義は[ComponentCreator]タブ、コンポーネントの値の設定は[ProductParams]タブでそれぞれ設定されています。
画面では、"Bottle"の色やサイズを変更しています。
コンポーネント毎にサイズについてのプロパティ値やプロパティの数が変わるため、[ProductParams]タブの各値は、[ComponentCreator]タブのコンポーネントの値を変更する、または[既定]タブの"Product"を別の値に変更した際に初期値に戻ります。
画面では、先ほど変更した"Bottle"のプロパティが初期設定に戻っています。
また、"ComponentCreator"のパーツ定義も、"Product"で別の値を選択した際に初期値に戻ります。
画面では、"Bottle"のコンポーネントにBoxのVCIDを設定しましたが、初期設定に戻っています。
この2タブの設定は、[既定]タブの"ResetShapeFeeder"をクリックすることで、"Product"の選択を含めて初期化されます。
これは、生成するパーツがPythonScriptで記述されており、"ResetShapeFeeder"をクリックすることでその内容を読み込んで初期値として反映するからです。
[モデリング]タブ-"Shape Feeder"-"ビヘイビア"-"PythonScript"をクリックするとPythonScriptの確認・編集ができます。
パーツ名とVCIDを管理している"Product"や、"ResetShapeFeeder"などの処理内容が記述されています。
このProductに追記することで、[既定]タブで選択できる"Product"を追加することができます。
試しに追記してみましょう。
書式は、"Product名　： VCID"です。
追加する際は、"Product"の情報を区別するためのカンマも追記してください。
追加したら、"PythonScript"をコンパイルして、[ホーム]タブをクリックします。
"ResetShapeFeeder"をクリックします。
シミュレーション実行前は選択できませんが、実行後は、"Product"で追加したパーツが選択できるようになります。
画面では、"Product"に"Sample"が追加できました。
以上で、Shape Feederの説明を終わります。
ご視聴ありがとうございました。

=================================================================================

シミュレーション中に製品を生成しよう（5/10）

シミュレーション中に製品を生成する、Pattern Feederの使い方
https://youtu.be/LcyMmKBlwqE

本動画では、Pattern Feederについて説明します。
初めに、[eカタログ]-[タイプ別モデル]-[Feeders]-[Visual Components]をクリックします。
"Pattern Feeder"を3Dワールドにドラッグ&ドロップします。
接続していたフィーダーを削除し、「Pattern Feeder」と「Conveyor」をPnPで接続します。
シミュレーションを実行すると、フィーダー後方にアタッチされているコンポーネントが生成されます。
"Pattern Feeder"は、複数のコンポーネントを1つのコンポーネントにアタッチした状態で生成します。
"Pattern Feeder"でのパーツの定義は、階層を持つコンポーネントを"SetTemplate"にアタッチすることで定義することができます。
実際にパーツを定義してみましょう。
フィーダーに接続されているパレットを削除します。
[Products and Containers]-[Visual Components]から、"Box"、"Cola Can"、"Parametric Pallet"を3Dワールドにドラッグ&ドロップします。
「Parametric Pallet」の[コンポーネントプロパティ]の[既定]タブから"PalletW"と"PalletL"を"ConveyorLength"と同じにします。
「Box」を「Parametric Pallet」の上に移動し、Z軸に15移動します。
「Cola Can」を「Box」の中へ移動し、"Z"を30に変更します。
「Cola Can」から「Box」へ、「Box」から「Parametric Pallet」へアタッチをします。
「Parametric Pallet」をフィーダーの後方に移動します。
「Parametric Pallet」から"SetTemplate"へアタッチをします。
シミュレーションを実行すると、パーツが生成されます。
パーツの出力が初期設定のままになっているため、[Pattern]タブから設定を修正します。
「Pattern Feeder」をクリックします。
[コンポーネントプロパティ]ウィンドウ-[Pattern]タブをクリックします。
"HierarchyLevels"は設定できる階層数です。
3以上に設定するには、PythonScriptを修正する必要があります。
"Count"でその軸方向のコンポーネントの数、"Step"で間の距離を設定できます。
12本のコーラが入った箱を4つ生成するパレットが定義できました。
以上で、Pattern Feederの説明を終わります。
ご視聴ありがとうございました。

=================================================================================

シミュレーション中に製品を生成しよう（6/10）

シミュレーション中に製品を生成する、Feeder Pointの使い方
https://youtu.be/FnIrnFoCRpo

本動画では、「Feeder Point」について説明します。
初めに、[eカタログ]-[タイプ別モデル]-[Feeders]-[Visual Components]をクリックします。
"Feeder Point"を3Dワールド上にドラッグ&ドロップします。
接続していたFeederを削除し、Feeder PointとConveyor をPnPで接続します。
シミュレーションを実行します。
初期設定のままでは、パーツは生成されません。
[ComponentCreator]タブに移動してパーツを定義します。
"Part"から3Dワールドのコンポーネントが選択できるため、"Box"を選択します。
シミュレーションを実行すると、Boxが生成されます。
[既定]タブについて説明します。
"ParentComponent"と"ParentBehaviour"は、接続しているインターフェースのコンポーネントとビヘイビアを表示しています。
値は接続しているインターフェースに依存するため、ここで修正はできません。
また、コンベアの端だけではなく、コンベア上にも接続することができます。

=================================================================================

シミュレーション中に製品を生成しよう（7/10）

シミュレーション中に製品を生成する、Pallet Feederの使い方
https://youtu.be/KhzmJUKDq20

本動画では、「Pallet Feeder」について説明します。
初めに、[eカタログ]-[タイプ別モデル]-[Feeders]-[Visual Components]をクリックします。
"Pallet Feeder"を3Dワールドにドラッグ&ドロップします。
接続していたフィーダーを削除し、「Pallet Feeder」と「Conveyor」をPnPで接続します。
シミュレーションを実行すると、パレットが積んだ状態で生成され、最下段から一つずつコンベア上に流れます。
コンベアの接続方向によって、パレットの流れ方が変わります。
「Conveyor」の"ConveyorLength"を"3000"に変更して、接続する位置を変更して、「Pallet Feeder」と「Conveyor」を再度PnPで接続します。
シミュレーションを実行します。
パレットの流れ方が変化しました。
[既定]タブについて説明します。
"Turn Palette"は生成するパレットの向きを変更します。
生成するパーツは、[Pallet]タブで定義されています。
"NumberOfPallets"で生成するパーツの段数、"RestockDelay"で全段流し終えた後、再生成するまでのインターバルが設定できます。
以上で、Pallet Feederの説明を終わります。
ご視聴ありがとうございました。

=================================================================================

シミュレーション中に製品を生成しよう（8/10）

シミュレーション中に製品を生成する、Pallet Filterの使い方
https://youtu.be/QU3SeFf8o4s

本動画では、Pallet Filterについて説明します。
初めに、[eカタログ]-[タイプ別モデル]-[Feeders]-[Visual Components]をクリックします。
"Pallet Filter"を3Dワールド上にドラッグ&ドロップします。
[タイプ別モデル]-[Conveyors]-[Visual Components]から"Conveyor"を3Dワールド上にドラッグ&ドロップします。
「Pallet Filter」とコンベアをPnPで接続します。
シミュレーションを実行しても何も生成されません。
"Pallet Filter"は、コンポーネントが流れてきたときにパーツを生成し、流れてきたコンポーネントにアタッチします。
先ほど作成した「Pallet Feeder-Conveyor」と「Pallet Filter-Conveyor」をPnPで接続します。
シミュレーションを実行すると、パレットが「PalletFilter」上にきたとき、パレットの上に"Visual Components Box"を生成しています。
[既定]タブについて説明します。
"FillDelay"は生成が完了するまでにかかる時間を定義します。
初期設定では、"FillDelay"は"0"でしたが、画面では"値"を"5"に変更して実行しています。
"PatternType"は、生成するパーツの個数や位置などの設定を決めます。
各タイプの詳細な設定は、そのタイプ名のタブで行います。
"Custom"の時に使用する設定は、[Custom Pattern]タブからノートに記述します。
生成するパーツ数分の座標がカンマ区切りで入力されています。
"PatternType"が"XYZ"の時は、[XYZ Pattern]タブのプロパティ値に従ってパーツが生成されます。
"_Countは各軸に生成するパーツの数、"_Step"は各軸のパーツを配置する位置の間隔を設定します。
画面では、一段当たりのパーツ数とパーツ間の間隔が増加しました。
"Flip_","_Fill_Order"は、各軸の生成するパーツを配置するスタート位置が変更できます。
"ProductOrientation"は、生成するパーツの角度を設定します。
画面では、各軸45度ずつ傾いた状態でパーツが生成されるようになりました。
以上で、Pallet Filterについての説明を終わります。
ご視聴ありがとうございました。

=================================================================================

シミュレーション中に製品を生成しよう（9/10）

シミュレーション中に製品を生成する、Bowl Feederの使い方
https://youtu.be/55v0GYfnfCA

本動画では、Bowl Feederについて説明します。
初めに、[eカタログ]-[タイプ別モデル]-[Feeders]-[Visual Components]をクリックします。
"Bowl Feeder"を3Dワールドにドラッグ＆ドロップします。
先ほどのフィーダーからコンベアを一つ外して、「Bowl Feeder」とPnPで接続します。
シミュレーションを実行します。
"Bowl Feeder"は多くのフレームが定義されており、生成されたパーツはこのフレームに、従い側面にそって移動します。
[既定]タブについて説明します。
"SimpleMode"は、シミュレーション実行中の動作が変わります。
"Enabledすると、動作が簡略化します。
"Bowl Feeder"は、あらかじめパーツを[既定]タブの"PartsInBowl"分生成して、その後インターバルを挟みながら1つずつ流します。
画面では、値を"10"に変更したため、"Bowl Feeder"が一度に生成するパーツの数が10個になりました。
"BowlWallAngle"は側面の角度を設定します。
設定できる範囲は5~75度です。
"BasePlateHeight"及び"BasePlateWidth"は、フィーダーの底の部分の設定になります。
"Spiral"は、パーツの回転方向を定義します。
パーツは[Product]から選択します。
選択できるのは"Hexagonal Nut"と"Attached Part2の二種類で、サイズやVCIDについては、他の2タブから設定できます。
以上で、Bowl Feederの説明を終わります。
ご視聴ありがとうございました。

=================================================================================

シミュレーション中に製品を生成しよう（10/10）

シミュレーション中に製品を生成する、Signal Feederの使い方
https://youtu.be/aHxBAc7UutQ

本動画では、Signal Feederについて説明します。
初めに、[eカタログ]-[タイプ別モデル]-[Feeders]-[Visual Components]をクリックします。
"Signal Feeder"を3Dワールドにドラッグ&ドロップします。
「Bowl Feeder」を削除して、「Signal Feeder」とコンベアをPnPで接続します。
シミュレーションを実行しても、なにも生成されません。
Signal Feeder は、パーツの生成をシグナルで制御します。
まず、生成するパーツの設定を行います。
[既定]タブに移動します。
"Signal Feeder"は、Feeder自体はパーツの定義を行いません。
受信したシグナルを"CreateSignalType"で設定したプロパティ値として扱い、その値と合致するコンポーネントが3Dワールド上にあれば、そのコンポーネントを生成します。
"CreateSignalType"は、受信したシグナルをどの値として使うかを設定します。
ComponentNameとして使う"CompName"、ProdIDとして使う"ProdID"、もしくは:で区切って両方を使う"CompName:ProdID"、の3種類があります。
今回は、3Dワールドにすでに配置されている、ComponentNameがBoxのコンポーネントを生成するようにしたいため、"CreateSignalType"は"CompName"を選択します。
[コンポーネントプロパティ]の"CompName"と"ProdID"にはあらかじめ値が入っていますが、シグナルを受信したらその都度更新されます。
次に、シグナルを送信するプロセスを設定します。
[タイプ別モデル]-[PM Flow Components]をクリックし、"Process Node"を3Dワールドにドラッグ&ドロップします。
[プロセス]タブ-[エディタ]-[プロセス]をクリックし、「Process #1」を選択します。
既存のステートメント文を削除し、"シグナル送信と"Delay"を追加します。
"SendSignal"を選択します。
[ステートメントプロパティ]ウィンドウから"コンポーネント"を"Signal Feeder"、"Signal"を"CreateSignal"、"値"に"Box"を入力します。
文字列として送信するのでダブルコーテーションを追加します。
シミュレーションを実行すると、10秒ごとにシグナルを受信し、Boxを生成します。
ほかのFeederで設定していたインターバルは、"Signal Feeder"にはないため、"Delay"がインターバルの役割を担います。
[既定]タブについて説明します。
"AddCreatorInfo"は、生成したパーツに"Creator"の情報を記載します。
画面の場合、"AddCreatorInfo"を有効にした場合、生成したBoxに値が"SignalFeeder"の"Create"プロパティが追加されています。
"PartPositioning"は、生成したパーツのオフセットを設定します。
"RandomOffset"の場合は、生成したパーツの位置がランダムで変わります。
以上で、Signal Feederの説明を終わります。
ご視聴ありがとうございました。

=================================================================================

シミュレーション中に統計情報を取得して表示させよう

生産数などを、統計情報のグラフに表示する方法
https://youtu.be/FtqXK9QEi0E
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_082.zip

本動画では、シミュレーション再生中に統計情報を取得して、画面に表示する方法について説明します。
まず初めに、レイアウトを作成します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Conveyors]-[Visual Components]から"Shuttle Conveyor"を3Dワールドにドラッグ＆ドロップします。
[コンポーネントプロパティ]ウィンドウ-[既定]タブから、"ShowPortNames"にチェックを入れます。
「Shuttle Conveyor」に設定されているポートの位置にポート名が表示されます。
デフォルトで設定されている5つのポートにコンベアを接続します。
[タイプ別モデル]-[Conveyors]から、"Conveyor"を3Dワールドにドラッグ&ドロップします。
[マニピュレーション]-[PnP]を選択した状態で「Conveyor」をドラッグして、"Shuttle Conveyor"の"Port #1"に近づけ接続します。
この時、"Conveyor"上の黄色の三角アイコンが「Shuttle Conveyor」へ向いた状態で接続してください。
同様の手順で、2つ目の"Conveyor"を追加して、「Shuttle Conveyor」の"Port #2"と接続してください。
"Conveyor"を3Dワールドにドラッグ&ドロップします。
[マニピュレーション]-[PnP]を選択した状態で「Conveyor #3」をドラッグして、"Shuttle Conveyor"の"Port #3"に近づけ接続します。
この時、"Conveyor"の三角アイコンが「Shuttle Conveyor」の反対側を向いた状態で接続してください。
同様の手順で、4つ目・5つ目の"Conveyor"を追加して、「Shuttle Conveyor」の"Port #4"、"Port #5"と接続してください。
[タイプ別モデル]-[Feeders]から"Advanced Feeder"を2つ、3Dワールドにドラッグ&ドロップします。
[マニピュレーション]-[PnP]を選択した状態でそれぞれドラッグし、「Conveyor」と「Conveyor #2」に近づけ接続します。
「Shuttle Conveyor」の設定を変更します。
「Shuttle Conveyor」をクリックします、[コンポーネントプロパティ]ウィンドウの下の方にある"Routing Rule"を展開します。
"タイプ"を"環状ルール"に変更します。
環状ルールは、設定した順番通りに繰り返し製品を流すルールです。
"接続もしくはルールを追加"を、製品を流したいポートの数分である三回クリックします。
追加した[コネクションもしくはルール]をクリックし、上から順に"Port 3","Port 4","Port 5"と設定します。
シミュレーションを再生します。
"Routing Rule"に設定した順で製品が輸送されます。
次に、このレイアウトから統計情報を取得して表示するように設定します。
統計情報について設定するには、[ホーム]タブ-[統計情報]をクリックします。
[統計情報]ウィンドウが表示されます。
統計情報を表示するダッシュボードのレイアウトを決めます。
今回は"2列2行 標準ダッシュボード"を選択して"クリエイト"をクリックします。
使用できるチャートは、表示する統計情報とグラフ形式を自由に設定できる"シンプルチャート"と、表示する統計情報とグラフ形式があらかじめ定義されている"テンプレートチャート"があります。
今回は、シンプルチャートを使います。左上のウィンドウでラインチャートをクリックします。
チャートを追加したら、画面右側に[プロパティ]ウィンドウが表示されます。
各プロパティについて説明します。
まず、グラフのプロパティについて説明します。
"名称"は、グラフタイトルの設定です。
"Sample"に変更します。
"説明文の可視性"は、データ系列の名称の表示/非表示を設定します。
"タイトルの可視性"は、グラフ名称の表示/非表示を設定します。
"サンプリング間隔"は、サンプリングを行う間隔を設定します。
-1の場合、リボンの[統計情報]-[間隔]の値が適用されます。
"種類"は、このグラフの種類の設定です。
今回は"ラインチャート"を選択したので、"線"が設定されています。
次に、データ系列のプロパティについて説明します。
"名称"は、データ系列の名称を設定します。
"コンポーネント"は、データを取得する対象のコンポーネントを設定します。
"3Dワールドからプロパティ値を選択クリックすると、3Dワールド上のコンポーネントを選択して設定できます。
"項目の追加/削除クリックすると、リストボックスから選択して設定ができます。
"プロパティ"は、データを取得するプロパティを設定します。
"コンポーネント"に設定したコンポーネントが持つプロパティをドロップダウンリストから選択します。
"厚さ"は、表示するグラフの線の太さの設定です。
データ系列を設定して、統計情報を取得してダッシュボードに表示してみましょう。
今回は、"Port3~5"に接続している「Conveyor」へ流れてきた製品の数を表示するように設定します。
"コンポーネント"に、"Conveyor #3"、"Conveyor #4"、"Conveyor #5"を追加します。
系列の名称に"PartsEntered"を入力します。
[プロパティ]を"Statistics.PartsEntered"に変更します。
統計情報を取得する間隔を変更します。
[統計情報]-[間隔]は、統計情報を取得する間隔を設定します。
この値を"1"に変更します。
シミュレーションを再生します。
コンベア上に流れてきたパーツの数が統計情報のダッシュボードで確認できます。
ダッシュボードの右上にカーソルを合わせると、画面の最小化/最大化ができます。
マウスホイールでグラフのズームイン/ズームアウトもできます。
グラフ上をドラッグして範囲を選択することで選択した範囲にズームインできます。
シミュレーションをリセットして、再度実行すると前回のシミュレーション時に取得した統計情報は削除されます。
その前に統計情報をエクスポートしたい場合は、[統計情報]-[グラフをエクスポート]からエクスポートできます。
ファイル形式は、ExcelファイルとCSVファイル形式が選択できます。
"グラフをエクスポート"をクリックし、ファイル形式を選択します。
ファイルの保存先を指定するダイアログが表示されるので、任意の保存先を指定し"保存"ボタンを押下します。
保存が完了すると、拡張子の対応した既定のアプリケーションで自動的にファイルが開きます。
ファイルには、シミュレーション開始～出力時までのデータが[間隔]毎に改行され、出力されています。
データ行は、左からシミュレーション経過時間であるSimulation Time、グラフにプロットしたデータ1つ目、2つ目以降データ分だけ並びます。
先ほど同様の手順で、コンベアから出て行ったパーツの数を取得して表示するよう設定を追加します。
Excelを閉じてGeminiの画面に戻ります。
シミュレーションをリセットします。
[統計情報]ウィンドウ"Sample"をクリックします。
[プロパティ]ウィンドウの"系列を追加"をクリックします。
"#2"の"名称"を"PartsExited"に変更します。
"コンポーネント"に"Conveyor #3"、"Conveyor #4"、"Conveyor #5"を追加します。
[プロパティ]を"Statistics.PartsExited"に変更します。
シミュレーションを再生します。
コンベアに流れてきたパーツと、コンベアから出て行ったパーツの数をダッシュボードで確認できます。
"データ系列"の"プロパティ"には、名前に「Interval」が含まれているものがあります。
例えば、"Statistics.PartsIntervalEntered"などがあります。
PartsEnterdの[プロパティ]を"Statistics.PartsIntervalEntered"に変更します。
"PartsIntervalEntered"と"PartsEntered"では、情報を取得する範囲が変わります。
先ほどの"PartsEntered"は、シミュレーション再生時にコンベア上に流れてきたパーツの総量を取得して表示します。
対して、"PartsIntervalEntered"は、シミュレーション再生時間を、統計情報の[間隔]の時間で区切った時の、その区間内で流れてきたパーツの数を取得して表示します。
そのため、"Interval"が含まれているプロパティを使う場合は、[間隔]を適切に設定する必要があります。
今回の場合は、[間隔]を"60"に変更します。
シミュレーションを再生します。60秒ごとに、ダッシュボードのグラフが更新されます。
また、PartsEnteredの値は、その区間の60秒で流れてきたパーツの数になります。
以上で、「シミュレーション中に統計情報を取得して表示させよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

シミュレーション中の様子をアニメーションで録画しよう

シミュレーション結果をアニメーションとして録画し、モバイル端末で閲覧できるようにする。(Experience形式)
https://youtu.be/1Fju220JUqo

本動画では、シミュレーション再生中の様子をアニメーションで録画する方法について説明します。
まず初めに、レイアウトを配置します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Layouts]から"Machine Tending"をダブルクリックします。
レイアウトを配置できたら、録画を行います。
"シミュレーションコントロール"の"アニメーションにエクスポート"をクリックします。
[アニメーションにエクスポート]ウィンドウが表示され、"Frame rate"が設定できます。
設定をしたら、"録画を開始"または"シミュレーションコントロール"の"再生"をクリックします。
ファイル名と保存先を指定して"保存"をクリックします。
シミュレーションが再生され、録画を開始します。
3Dワールド全てが録画対象なので、録画中にシミュレーション速度や視点を切り替えても問題なく録画できます。
"停止して保存クリックすると、録画が停止します。
保存したファイルは、Visual Components Experienceで再生できます。
今回は、ソフトウェアのVisual Components Experienceを使って、エクスポートしたファイルを再生します。
Visual Components Experience で、先ほど保存したファイルを開きます。
3Dをクリックします。
画面操作について説明します。
画面下部のボタンで、シミュレーションの再生/停止、リセットができます。
画面中央を操作することで、視点の切り替えや拡大/縮小ができます。
画面右上から、シミュレーション再生速度を変更できます。
以上で、「シミュレーション中の様子を動画で記録しよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

シミュレーション中の様子を録画しよう

シミュレーション実行時に、ビデオにエクスポート機能を使用して、動画ファイル（avi、mp4、mov）に保存する方法（ビューエディタ、Fly Camera）
（関連動画：録画する時のカメラの視点を設定しよう、シミュレーション中の様子をアニメーションで録画しよう）
https://youtu.be/XYei-YnaBD0
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_139.zip

本動画では、シミュレーションを録画してエクスポートする方法について説明します。
初めに、「シミュレーション中の様子を録画しよう.vcmx」を開きます。
シミュレーションを録画するにはビデオ機能を使用します。
シミュレーションコントロールにある"ビデオへのエクスポート"をクリックするか、
[エクスポート]-[ビデオ]をクリックします。
[ビデオにエクスポート]ウィンドウが開き、ビデオの解像度、フレームレート、エンコード方法、品質等のオプションが表示されます。
現在の解像度は480で、ビューポート内の赤い枠が録画される範囲を示しています。
この枠内のものだけが録画されます。
ビューポートのサイズを変更すると、赤い枠の範囲が変更されます。
解像度のオプションには、"画面解像度"という選択肢があります。
これを選ぶと赤い枠が消え、ビューポートの高さと幅がビデオの解像度として使用されます。
ビューポートをリサイズすると、それがビデオの解像度になります。
また、F11キーを押下するとフルスクリーンモードになり、このモードで録画することも可能です。
F11キーを再度押下すると元のサイズに戻ります。
デフォルトのビューポートサイズに戻すには、
[ウィンドウ]-「ウィンドウの復元」をクリックします。
今回は解像度を"1080"で録画します。
フレームレートは25、30、60から選べます。
今回は"25"を選びます。
ビデオコーデックはAVI、MP4、または非圧縮のQuickTimeムービーが選べます。
今回は"AVI"を選びます。
品質は低、中、高、または非圧縮から選べます。
今回は"高"を選びます。
録画を開始する準備ができたら、"録画を開始"ボタンをクリックするか、
シミュレーションコントロールの"録画"をクリックします。
今回はシミュレーションコントロールの"録画"をクリックします。
次に、ファイル名とビデオを保存する場所を指定します。
今回は使用しているレイアウトのデフォルト名を使用します。
"保存"をクリックすると、シミュレーションと録画が自動的に開始されます。
"ビデオにエクスポート"のウィンドウに、録画中のプレビューが表示されます。
プレビューにはシミュレーションコントロール、浮動原点、3Dワールドツールバー、ビューセレクター、マウスポインターは表示されません。
これらはレイヤーアイテムであるため、録画されません。
しかし、シーン内の他のすべてのもの、つまり、コンポーネント、床、背景、カメラの動きなどは録画されます。
カメラを回転させたりズームしたり、パンした内容が録画されることをプレビューで確認できます。
録画を保存したい場合は、"停止して保存"をクリックします。
録画をやり直したい場合は、"リセット"ボタンをクリックすると、ビデオファイルは作成されません。
ビデオファイルを作成しないため、"リセット"ボタンをクリックし、録画をキャンセルします。
再度録画を開始します。
録画中にフレームの可視性やレンダリングモードを変更することができます。
3Dワールドツールバーの、フレームタイプの"フレーム"をオン/オフすることで、
フレームの表示/非表示を変更でき、プレビューでもそれを確認できます。
レンダリングモードを"ワイヤフレーム"に変更し、録画することもできます。
レンダリングモードを"シェード"に戻します。
3Dワールドツールバーのヘッドライトは現在オフになっています。
"ビューセレクタ"でトップからの視点に切り替え、3Dワールドツールバーのヘッドライトをオンにします。
コンポーネントをどの角度から見ても光が当たるため、カメラを回転させても、光が当たっていることを確認できます。
シミュレーション中にカメラの動きを変更する方法がもう一つあり、ビューエディタを使用することです。3Dワールドツールバーのビューエディタをクリックすると、設定済みのユーザービューがあります。
ユーザービューの"Default"ビューをクリック後、"Top View of Machine"ビューをクリックします。
カメラの動きが録画されていることがプレビューで確認できます。
また、3Dワールドツールバーのビューエディタはレイヤーアイテムなので、録画されません。
マウスでカメラを操作する代わりに、ユーザービューを使ってカメラの動きを変更することができます。
シミュレーションをリセットし、録画をキャンセルします。
後で使用するためにユーザービューを追加します。
マシンのプロセスとロボットが部品をピックアンドプレースする動作を確認できる視点に切り替えてビューを追加します。名前は"ProcessView"に変更します。
シミュレーションをビデオとして録画するためのツールに、"Fly Camera"があります。
これは、シミュレーション中にカメラのプログラムを実行することを可能にします。
[eカタログ]-[タイプ別モデル]-[Misc]-[Visual Components]に移動し、"Fly Camera"を3Dワールドにドラッグ＆ドロップします。
"Fly Camera"では、シミュレーションを再生するときに実行されるプログラムであるPythonスクリプトを作成できます。
カメラの始まりの位置を"ビューセレクタ"で設定し、[コンポーネントプロパティ]ウィンドウの"AddView"ボタンをクリックします。
"AddAnimatedView"ボタンはアニメーションビューを追加するオプションです。
まず、"ビューセレクタ"で移動後のカメラの位置を設定します。
次に"ViewDelay"に10を設定し、"AddAnimatedView"ボタンをクリックします。
これで10秒かけてカメラを移動させるアニメーションが作成できました。
また、遅延や待機を作成することもできます。
"ビューセレクタ"で遅延後に移動させたいカメラの位置を設定し、"DelayTime"に5を設定し、"AddDelay"ボタンをクリックします。
その後に、"AddView"ボタンをクリックします。
これで5秒遅延後に、新しいビューに移動する動きを作成できました。
また、"AddWait"ボタンをクリックすることで、待機を作成することもできますが、これはシミュレーション時間に基づきます。
"Fly Camera"のプログラムを確認するには、3Dワールドの"Fly Camera"にあるメモアイコンをクリックするか、[コンポーネントプロパティ]ウィンドウの、[Views]タブにある「エディタで開く」ボタンをクリックするとプログラムが記載された"ノートエディタ"が開かれます。
まず、1行目に「View」という名前のユーザービューがあり、2行目に「View2」へ10秒かけて移動するアニメーションビューがあります。
3行目に5秒間の遅延があり、4行目で「View3」に移動します。
そして5行目に待機がありますが、手動で入力する必要があるため、シミュレーションが30秒になるまで待機するように設定します。
追加で「View2」に戻るためのアニメーションを作成します。2行目のアニメーションをコピーして、最後に貼り付けます。
これがどのように動作するか見てみます。
"ノートエディタ"を閉じます。3Dワールドのメモアイコンを表示したくない場合は、"Fly Camera"の選択を解除します。
再度録画開始すると、カメラが作成したビューに合わせてアニメーション化されていることがわかります。
また、[出力]ウィンドウで、ノートエディタのどの行のコードを実行しているかが確認できます。
録画を保存するには、シミュレーションコントロールの"停止"ボタンをクリックするか、[ビデオにエクスポート]ウィンドウの"停止して保存"ボタンをクリックしますが、もう少し変更を加えたいためビデオファイルを作成せずにリセットをクリックします。
[ビデオにエクスポート]ウィンドウには、もう1つ便利な機能があり、シミュレーションを自動的に停止してビデオを保存する機能があります。
そのため"Fly Camera"のPythonスクリプトを、「ビューエディタの"Default"ビューから始めて、"Top View of Machine"ビューまでをアニメーションで移動後、"ProcessView"に移動させる」ように、変更します。
3Dワールドツールバーのビューエディタをクリックすると、"Fly Camera"がこれまでのレイアウトビューを作成していることがわかります。
これらは必要ないため削除します。
"Default"ビューをクリックします。
"Fly Camera"を選択し、ノートエディタを開きます。
まず、"Default"ビューに移動したいので、"View"の代わりに"Default"ビューに変更します。
次に、"View2"の代わりに"Top View of Machine"ビューをアニメーション化します。
そして10秒後に"ProcessView"に移動したいので、遅延を5秒から10秒に変更します。
最後に、"view"を"animate"に、"View3"を"ProcessView"に変更し、5秒かけて移動するアニメーションにします。残りの2行は不要なため削除します。
"ノートエディタ"を閉じて、録画を開始します。
まず、"Default"ビューに移動後、10秒かけて"Top View of Machine"ビューに移動し、10秒遅延してから"ProcessView"に5秒かけて移動します。
動作に問題ありませんが、まだビデオファイルを作成しないためリセットし、[出力]ウィンドウをクリアします。
"ProcessMachine Lathe"の信号を"Fly Camera"の信号に接続して、カメラを移動させたいときに信号を送るようにします。
"Fly Camera"のPythonスクリプトにいくつかの変更を加えるため、"ノートエディタ"を開きます。
まず、2行目に5秒間の遅延を追加します。
次に、"Fly Camera"の[コンポーネントプロパティ]ウィンドウの、[既定]タブに移動します。
ここには信号に関するオプションがあり、デジタルまたはBool信号としてのバイナリ入力を待つことも信号の値を設定することもできます。
"SignalValue"と"WaitTrigger"にチェックを入れます。
これは信号値をTrueとし、信号イベントを待つようにします。
"WaitForBinaryInput"ボタンをクリックします。
"ノートエディタ"で更新されたことが確認できます。
入力信号名は"TriggerSignal"と定義されTrueである必要があり、信号イベントを待つため、最後の要素もTrueになります。
これを切り取り、4行目の遅延を削除し、そこにペーストします。
"ProcessMachine"から部品があるという入力を受け取った後に、"ProcessView"にカメラが移動するために、"Fly Camera"の信号と"ProcessMachine"の信号を接続する必要があります。
[接続]-[シグナル]をクリックします。
"Fly Camera"には"TriggerSignal"があり、"ProcessMachine"には"TriggerSignal"と互換性のある"TransSignal"があるため、それらを接続します。
オレンジの円をドラッグしてワイヤーを表示し、"TriggerSignal"にドロップして接続します。
[接続]-[シグナル]をクリックし、シグナルを非表示にします。
再度録画を開始します。
"Default"ビューから5秒後にカメラが移動を開始し、10秒かけて"Top View of Machine"ビューに移動します。
そして、カメラは"TransSignal"の信号を待ってから"ProcessView"に移動します。
この動作に約40秒かかるため、40秒後に自動でシミュレーションを停止して録画ファイルが作成されるようにします。
再度シミュレーションをリセットします。
シミュレーションコントロールの設定をクリックします。
"シミュレーションの実行時間"や"時計表示モード"、リアルタイムでシミュレーションを実行するか、仮想時間で実行するか等のオプションがあります。
現在、"シミュレーションの実行時間"は無限の実行時間で実行しているため、シミュレーションは時間制限なく再生されます。
"カスタム"ボタンをクリックし、シミュレーション時間を40秒に設定します。
これでシミュレーションが40秒に達すると、自動的に停止し、ビデオが保存されます。
再度録画を開始し、40秒になるのを待ちます。
40秒になるとシミュレーションが停止し、保存されたビデオが開かれます。
以上で、「シミュレーション中の様子を録画しよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

ツールを使って製品を輸送してみよう

人が台車（Pallet Jack）を使って製品を輸送する方法
https://youtu.be/GYf8jv0a5D4
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_121.zip

本動画では、輸送タスクを行う時にツールを使うように設定する方法を説明します。
初めに、「ツールを使って製品を輸送してみよう.vcmx」を開きます。
このシミュレーションでは、「Human」が"Feeder"-"ManualProcess"間でツールを使って輸送タスクを行います。
輸送タスクを行うために、「Human」がツールを使用するように設定する必要があります。
まず初めに、使用するツールを設定します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Tools]から"Pallet Jack"を2つ、3Dワールド上にドラッグ&ドロップします。
最初に追加した「Pallet Jack」を選択し、[コンポーネントプロパティ]ウィンドウから"名称"を"Pallet Jack #1"に変更します。
また、追加した2つのツールを外見で判別できるように、"Pallet Jack #1"の"マテリアル"を"orange"以外に変更します。
次に、「Pallet Jack #1」と「Pallet Jack #2」を、コントローラとインターフェース接続します。
[ホーム]タブ-[接続]-[インターフェース]をクリックします。
「Human Transport Controller」の"Tools"と、「Pallet Jack #1」と「Pallet Jack #2」の"Tool"を接続します。
これで、「Human」がタスクを行う時に、「Pallet Jack #1」と「Pallet Jack #2」を使用できるようになります。
ツールの設定は完了しました。
次に、トランスポートリンクの設定を変更して、作業を行う際にツールを使用できるようにします。
[プロセス]タブ-[エディタ]-[フロー]をクリックします。
[プロセスフローエディタ]ウィンドウ-"フローステップ"から"Feeder"-"ManualProcess"間のひし形アイコンをクリックするか、3Dワールド上のひし形アイコンをCtrlキーを押しながらすべてクリックすることで、トランスポートリンクをすべて選択状態とします。
こうすることで、トランスポートリンクの設定を一括で行うことができます。
選択状態のまま、[プロパティ]ウィンドウから"Tool"の設定を"Tool Name"に変更すると、新たに"ToolName"というプロパティが設定できるようになります。
"ToolName"に"Pallet Jack"を設定します。
"Tool"の設定を"Tool Name"に変更することで、「Human」が輸送タスクを行う時に、ツール名に"ToolName"で設定した名前が含まれているツールを使用するようになります。
シミュレーションを再生します。
"Feeder"-"ManualProcess"間で輸送タスクを行う際は、「Human」が「Pallet Jack #1」を使用するようになります。
"ToolName"は、使用するツールを探すための検索ワードとして使用されます。
そのため、設定する値は、使用したいツールの名称と完全一致である必要はありません。
また、"ToolName"の値を名称に含むツールが複数存在した場合、そのツールの中でリソースに最も近いものを使用します。
例えば、3Dワールド上の「Pallet Jack #1」をドラッグして、「Human」から距離を離します。
シミュレーションを再生します。輸送タスクを行う際は、「Pallet Jack #2」を使用するようになります。
"Tool"の他の設定について説明します。
"Product Property"を設定すると、"PropertyName"が設定できるようになります。
"PropertyName"には、輸送する製品に定義されているプロパティ名を設定します。
設定したプロパティ名の値と合致するツールが3Dワールド上にある場合、そのツールを使用します。
実際に"Property Name"からツールを指定してみましょう。
まず、フローの設定を変更します。
"Feeder"-"ManualProcess"間のひし形アイコンをクリックして、[プロパティ]ウィンドウを表示します。
"Tool"を"Product Property"に変更し、"PropertyName"に"MyTool"を設定します。
次に、製品タイプに、使用するツール名を定義するプロパティを追加します。
[プロセス]タブ-[エディタ]-[製品]をクリックします。
[製品タイプエディタ]ウィンドウ-"フローグループ番号1"-"VC_Can"-"製品プロパティ"を右クリックし、"製品プロパティを追加"をクリックします。
追加されたプロパティの設定を、[プロパティ]ウィンドウから変更します。
[名前]を"MyTool"、"Type"を"String"、"Default Value"-"MyTool"を"Pallet Jack #1"に変更します。
シミュレーションを再生します。製品を輸送する際は「Pallet Jack #1」を使用するようになります。
ここまではトランスポートリンク間で一括して設定を行いましたが、使用するツールを個別に設定することもできます。
使用するツールを個別に設定する場合について説明します。
ここでは「Feeder Process」から運ぶ時は「Pallet Jack #1」、「Feeder Process #2」から運ぶ時は「Pallet Jack #2」を使うよう設定します。
「Feeder Process」の"Feeder"を含んでいるひし形アイコンを3Dワールド上から複数選択し、[プロパティ]ウィンドウから設定を変更します。
"Tool"を"Tool Name"、"ToolName"を"Pallet Jack #1"に変更します。
次に、「Feeder Process #2」の"Feeder"を含んでいるトランスポートリンクも同様の手順で設定を変更します。
"Tool"を"Tool Name"、"ToolName"を"Pallet Jack #2"に設定します。
シミュレーションを再生します。輸送タスクによって、使用するツールを切り替えるようになりました。
以上で、「ツールを使って製品を輸送してみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

デタッチを使用してデパレタイズしてみよう

アタッチして搬入した製品同士を、デタッチで分ける方法
（関連動画：トランスポートインパターンを使用してパレタイズしてみよう）
https://youtu.be/zPOOcF1rplk
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_149.zip

本動画では、デタッチステートメントを使用してデパレタイズする方法について説明します。
「トランスポートインパターンを使用してパレタイズしてみよう」では、パレットにプレートとシリンダーを乗せてアタッチすることで、パレタイズを行いました。
今回は、そのパレットからプレートとシリンダーを取り外して外に運び出すデパレタイズを行います。
初めに、「デタッチを使用してデパレタイズしてみよう.vcmx」を開きます。
これは、「トランスポートインパターンを使用してパレタイズしてみよう」で作成したパレタイズ工程と同じものです。
シミュレーションを再生すると、パレットの上にプレートとシリンダーがパレタイズされます。
パレタイズされたパレットは、コンベアを流れていきます。
このコンベアの先に、デパレタイズ工程を作成していきます。
シミュレーションをリセットします。まず、元々配置してあったコンベアを選択し、"クローン"ボタンを押します。
これにより、元のコンベアにPnP接続された状態でコンベアがコピーされます。
コピーされたコンベアを見ると、コンベアにPnP接続されたプロセスノードも一緒にコピーされています。
ここをデパレタイズ作業の場所にします。
[プロセス]タブ-[エディタ]-[プロセス]をクリックします。
新しい方のLoadingのプロセスラベルをクリックして、[ルーチンプロパティ]ウィンドウから、[名前]を"Unloading"に変更します。
次に、[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Flow Components]から"Sink Process"を配置します。
ここは、デパレタイズしたシリンダーやプレートを受け取り、廃棄する場所になります。
次に、Unloadingのプロセスを修正します。
コピー元のステートメントがすでに入っていますが、パレタイズ作業は行わないので、TransportInとTransportOut以外のステートメントは全て削除しておきます。
まず、"TransportIn"の後ろにDetachを追加します。
"TransportIn"をクリックして、"ステートメント"-"デタッチ"をクリックします。
Detachステートメントを使うと、アタッチされた製品を取り外すことができます。
今回の場合は、パレットからシリンダーやプレートを取り外すことができます。
[ステートメントプロパティ]ウィンドウから、"Detach"のプロパティを設定します。
[製品変数名]には、分解したい製品の製品変数名を入力します。
今回は「PalletPart」と入力します。
"デタッチ変数名"では、[製品変数名]で指定した製品からデタッチした製品の変数名を指定することができます。
今回は"CylinderParts"と入力します。
"多くをデタッチ"は、チェックを入れると、分解する製品にアタッチされた製品を全てデタッチするようになります。
反対に、チェックを外すと、最後にアタッチされた製品ひとつだけをデタッチします。
今回は複数のシリンダーを一括でデタッチしたいので、チェックを入れます。
ただし、この設定だけでは、シリンダーだけでなくプレートも同時にデタッチしてしまいます。
そのため、シリンダーのみが対象となるように製品フィルターをかけます。
製品フィルターを展開します。
"製品タイプ"フィルターを追加し、"使用可能な製品タイプ"に"Cylinder"を追加します。
これで、パレットからシリンダーのみを全てデタッチすることができます。
続いて、DetachしたシリンダーをSink Processへ搬送するため、TransportOutを追加します。
"Detach"を選択した状態で"ステートメント"-"トランスポートアウト"をクリックします。
[ステートメントプロパティ]ウィンドウから、[製品変数名]に"CylinderParts"と入力します。
同様に、プレートもパレットから取り外した後Sink Processへ搬送するため、DetachとTransportOutを追加します。
3行目の"TransportOut"を選択した状態で、"ステートメント"-"デタッチ"と"トランスポートアウト"を順にクリックします。
4行目の"Detach"をクリックします。
[ステートメントプロパティ]ウィンドウから[製品変数名]には"PalletPart"と入力し、"デタッチ変数名"には"PlatePart"と入力します。
続いて"多くをデタッチ"や製品フィルターの設定ですが、今回は特に設定する必要はありません。
理由は、初めのDetachでシリンダーを全てデタッチしており、パレットにはプレート1つだけしかアタッチされていないからです。
続いて、5行目の"TransportOut"をクリックします。
[ステートメントプロパティ]ウィンドウから、[製品変数名]に"PlatePart"と入力します。
以上で、Unloadingのプロセスの設定ができました。
全体の流れとしては、まずコンベアからパレットを受け取り、シリンダーとプレートをデパレタイズし、再びコンベアへパレットを流す、という形になります。
次に、フローの設定をします。
[エディタ]-[フロー]をクリックします。まず、UnloadingとSinkの間にトランスポートリンクを作成します。
"Unloading"-"Sink"の順に、プロセスノードをクリックします。
続いて、UnloadingとSinkのプロセスラベルを、フローステップにあるLoadingの隣にドラッグアンドドロップします。
これで、UnloadingからSinkへ製品を搬送するフローを設定できました。
シミュレーションを再生します。
最初にLoadingでパレタイズ作業が行われますが、この部分を確認する必要は無いので、スキップしましょう。一度、パレタイズ作業が終わるまで待ちます。
パレタイズ作業が完了したタイミングで、シミュレーションを停止します。約2分50秒で、パレタイズ作業が完了します。
シミュレーションをリセットしてこの時間をウォームアップ時間に入力します。
再度、シミュレーションを再生します。
パレタイズ作業がスキップされ、デパレタイズ作業の直前からシミュレーションが始まりました。
Unloadingで、シリンダー、プレートの順にデパレタイズされます。
ここまでは順調です。
今度はデパレタイズ作業が終わった後の動きに着目してみます。
プレートがデタッチされ、Sinkへ運ばれるタイミングで、コンベアも動作していることが確認できます。
これを、プレートを運び始めてしばらく経ってから、コンベアが動作するように変更します。
[エディタ]-[プロセス]をクリックし、Unloadingのプロセスラベルをクリックします。
Plateを搬出する、5行目の"TransportOut"をクリックして、"ステートメント"-"ディレイ"をクリックします。
[ルーチンプロパティ]ウィンドウから秒数の設定ができますが、今回はデフォルトの10秒にします。
シミュレーションを再生します。
プレートが運ばれてからコンベアが動作する様子が確認できます。
現在のデパレタイズ作業は自動で行われていますが、作業者が作業を行うように変更することもできます。
実際に設定してみます。
まず、eカタログから「Human Transport Controller」と「Human (Anna)」を配置します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Transport Controllers]から、"Human Transport Controller"を3Dワールド上にドラッグ&ドロップします。
[タイプ別モデル]-[PM Resources]から"Human (Anna)"を3Dワールド上にドラッグ&ドロップします。
続いて、[ホーム]タブ-[接続]-[インターフェース]をクリックして、コントローラと人をインターフェース接続します。
最後に、トランスポートリンクのリソースを「Human Transport Controller」に設定します。
まず、[プロセス]タブ-[フロー]をクリックし、「Human Transport Controller」のひし形アイコンをクリックして、コントローラを選択した状態にします。
続いて、UnloadingからSinkへ設定されたトランスポートリンクを右クリックし、「トランスポートコントローラを変更」をクリックします。
以上の設定をすることにより、デパレタイズ作業を作業者が行うようになります。
シミュレーションを再生します。パレットからデタッチされたシリンダーを作業者が運ぶようになります。
しかし、作業場所がコンベアの内部になってしまっています。
これを修正します。
シミュレーションをリセットします。
まず、プロセスノードを選択します。
[コンポーネントプロパティ]ウィンドウから[ResourceOffset]の"Rz"を"-90"、"Ty"を"700"に変更します。
これで作業者は、コンベアの目の前のここ で作業を行うするようになります。
シミュレーションを再生します。
今まで自動で行われていたデパレタイズ作業を、作業者が行っている様子を確認できます。
作業位置もコンベアの目の前に設定されています。
以上で、「デタッチを使用してデパレタイズしてみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

トランスポートインパターンを使用してパレタイズしてみよう

複数の製品を並べて搬入する方法と、製品同士をアタッチして1つにまとめて同時に搬出する方法
（関連動画：デタッチを使用してデパレタイズしてみよう）
https://youtu.be/ehv3WgHAoVk
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_147.zip

本動画では、トランスポートインパターンステートメントを使用してパレタイズする方法について説明します。
トランスポートインパターンを使用すると、アセンブリ機能を使わずにパレタイズすることができます。
初めに、「トランスポートインパターンを使用してパレタイズしてみよう.vcmx」を開きます。
現在、パレタイズ前の製品とパレタイズ後の製品 が配置されています。
使用されているコンポーネントは、Cylinder 、Parametric Pallet、Euro Palletの3種類です。
また、[プロセス]タブ-[エディタ]-[製品]をクリックして製品タイプエディタを開くと、Cylinder、Plate、Palletの3つの製品タイプが定義されています。
コンポーネントURIはまだ定義されていないため、[プロパティ]ウィンドウから、CylinderにはCylinderを、PlateにはParametric Palletを、PalletにはEuro Palletを、それぞれ設定しておきます。
まずはパレタイズ前の製品を、パレタイズ後の形になるように配置します。
Parametric Palletを選択した状態で、[ホーム]タブ-[ツール]-[スナップ]をクリックします。
Euro Palletの中心にポインタが当たっている状態でクリックします。
Euro PalletとParametric Palletがぴったり重なりました。
次に、Cylinderを5×3に並べてパレット上に配置します。
Cylinderを選択した状態で、[ホーム]タブ-[ツール]-[パターン]をクリックします。
[パターン]ウィンドウの設定項目のうち、[パターンに沿って]が「+X」、[カウント]が「5」であることを確認して、[適用する]をクリックします。
続いて、[パターンに沿って]を「+Y」、[カウント]を「3」に変更して、もう一度[適用する]をクリックします。
最後に、Cylinderが全て選択された状態で[ホーム]タブ-[ツール]-[スナップ]をクリックし、パレットの上に配置します。
パレットの上にCylinderを、5×3に並べて配置することができました。
次に、パレットを生成するFeederと、そのパレットを流すコンベアを配置します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Flow Components]から、Feederを3Dワールド上にドラッグ&ドロップします 。
続いて、Feederが選択された状態のまま、[eカタログ]ウィンドウ-[タイプ別モデル]-[Conveyors]から、Conveyorをダブルクリックします。
これにより、ConveyorはFeederにPnP接続した状態で配置されます。
一度、シミュレーションを再生します。
コンベアを見ると、デフォルトで設定されているシリンダーが流れていますが、これをパレットに変更します。
シミュレーションをリセットします。
Feederをクリックします。
[コンポーネントプロパティ]ウィンドウ-[ProductCreator]タブから、パーツをPalletに変更します。
パレットの生成間隔が狭いので、"間隔"を120に変更します。
また、パレットに対してコンベアが小さいので、コンベアのサイズも変更します。
コンベアをクリックします。
[コンポーネントプロパティ]ウィンドウ-[既定]タブから"ConveyorLength"を"2500"、"ConveyorWidth"を"1000"に変更します。
もう一度シミュレーションを再生すると、パレットが流れる様子が確認できます。
シミュレーションをリセットします。
次に、[eカタログ]ウィンドウ-"タイプ別モデル-"PM Flow ComponentsからFeeder Processを3Dワールド上にドラッグ&ドロップして、2つ配置します。
1つはCylinder供給用なので、[コンポーネントプロパティ]ウィンドウ-[ProductCreator]タブから"パーツ"を"Cylinder"に変更します。
もう1つはPlate供給用なので、同様の手順で"パーツ"を"Plate"に変更します。
[プロセス]タブ-[エディタ]-[プロセス]をクリックします。
"Feeder Process"のプロセスラベルをクリックして、[ルーチンプロパティ]ウィンドウから、プロセス名をそれぞれ「Feeder_plate」と「Feeder_cylinder」に変更します。
続いて、パレタイズを行うためのプロセスノードを追加します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Flow Components]から"Process Node"を3Dワールド上にドラッグ&ドロップします。
[マニピュレーション]-[PnP]を選択した状態で、Process Nodeをコンベアに近づけ、PnP接続します。
Process Nodeのプロセス名をLoadingに変更します。
次に、フローの設定をします。
[エディタ]-[フロー]をクリックします。
Feeder Processを配置したことにより、余分なフローグループが2つ作成されているため、"フローグループ番号1"と"フローグループ番号2"は削除します。
残ったFlow Group #1に、フローを設定します。
[プロセスフローエディタ]ウィンドウの"Flow Group #1"をクリックします。
まずFeeder_plateとLoadingの間にトランスポートリンクを作成します。作成するときは両方ともプロセスラベルを選択することで、フローステップも一緒に作成します。
一旦何もないところをクリックして選択を外した後、今度はFeeder_cylinderとLoadingの間にトランスポートリンクを作成します。
こちらはプロセスラベルを選択しません。
最後に、Feeder_cylinderプロセスラベルを、[プロセスフローエディタ]ウィンドウのFeeder_plateの下にドラッグ&ドロップします。
これで、2つのFeederからLoadingへ製品を供給するフローを設定できました。
次に、Loadingのプロセスを設定します。
まずはパレットを受け取る設定から行います。
[プロセス]タブ-[プロセス]をクリックし、Loadingのプロセスエディタを開きます。
まず、TransportInの[ステートメントプロパティ]である[ソース]を設定します。
"TransportIn"をクリックして、[ステートメントプロパティ]ウィンドウを開きます。
フローステップに設定した前のプロセスからパレットを受け取る場合は「前のプロセスから」を指定しますが、今回はコンベアの内部コンテナから直接パレットを受け取るので、「コンポーネントコンテナから」を指定します。
また、製品変数名をPalletPartに変更します。
コンベアから流れてくる製品はパレットのみであるため、今回は製品フィルターをかける必要はありません。
一度シミュレーションを再生します。
パレットはプロセスノードの手前で停止しています。
シミュレーションをリセットします。
パレットが中心で止まるようにしたいので、プロセスノードをクリックし、[コンポーネントプロパティ]ウィンドウから[TriggerAt]をOriginに変更します。
再度シミュレーションを再生します。
パレットの停止位置が変わっていることを確認できます。
続いて、パレットの上に乗せるPlateとCylinderを受け取る設定をします。
シミュレーションをリセットします。
まず、TransportInの後ろにTransportPatternInを2つ追加します。
"TransportIn"をクリックして、"ステートメント"-"トランスポートインパターン"を2回クリックします。
先にPlateを受け取りたいので、一つ目のTransportPatternInではPlateのみを受け取るように設定します。
2行目の"TransportPatternIn"をクリックします。
[ステートメントプロパティ]ウィンドウから、"製品フィルター"を展開し、"製品タイプ"の製品フィルターを追加します。
"使用可能な製品タイプ"には"Plate"を選択します。
[製品変数名]も"PlatePart"に変更します。
続いて2つ目のTransportPatternInでは、Cylinderのみを受け取るように設定します。
3行目の"TransportPatternIn"をクリックします。
[ステートメントプロパティ]ウィンドウから、"製品タイプ"の製品フィルターを追加し、"使用可能な製品タイプ"には"Cylinder"を選択します。
[製品変数名]も"CylinderParts"に変更します。
シミュレーションを再生します。
パレット、プレート、シリンダーの順で受け取っている様子が確認できますが、個数や配置が、最初に配置したパレタイズ製品と異なります。
パレタイズ後の見た目がこのパレタイズ製品と同じになるように、追加で設定をしていきます。
シミュレーションをリセットします。
個数や配置を決定するプロパティは、"オフセット"、"パターンカウント"、"パターンステップ"です。
"オフセット"では、最初に配置する製品の座標を指定できます。
入力する値は、製品ポジションフレームを基点とした相対座標です。
"パターンカウント"では、X方向、Y方向、Z方向に配置する製品の個数を指定できます。
"パターンステップ"では、2つ目以降の製品を配置するときの、製品同士の間隔を指定できます。
まずはPlateの個数や配置を変更してみましょう。2行目のTransportPatternInをクリックします。
"オフセット"には最初のPlateを置く座標を、"製品ポジションフレーム"を基点とした相対座標で入力します。
今、"製品ポジションフレーム"は"NULL"となっているため、デフォルトのMainFrameが設定されます。
フレームは、3Dワールドツールバーのフレームタイプを有効にして、"フレーム"にチェックを入れると3Dワールド上に表示できます。
このMainFrameが位置するのはProcess Nodeの中心なので、ここを基点とした相対座標を入力することになります。
今回、プレートはパレットの真上に配置するため、X座標、Y座標は0のまま、変更する必要はありませんが、Z座標はPalletの上になるように値を設定する必要があります。
そこで、[ツール]-[測定]をクリックし、パレットの高さを測ります。
144mmでした。
これを"オフセット"の"Tz"に入力します。
これで、プレートはパレットより144mm高い位置に配置されるようになりました。
続いて"パターンカウント"を設定します。
プレートはパレットの上に1枚だけ載せるので、"X","Y","Z"は全て1と入力します。
最後の"パターンステップ"ですが、プレートは1つだけしか受け取らないため、特に設定する必要はありません。
以上で、Plateの個数と配置の設定ができました。
シミュレーションを再生すると、プレートがパレットの上に配置されていることが確認できます。
次に、Cylinderの個数や配置を変更してみましょう。
シミュレーションをリセットします。
3行目の"TransportIn"をクリックします。
[オフセット]は最初のCylinderを置く座標です。
X,Y,Z座標が一番小さい、このシリンダーの相対座標を設定します。
相対座標の基点はProcess NodeのMainFrameですが、これはコンベアで運ばれてきて停止したパレットの原点座標と一致します。
つまり、パレットの原点を基点としたシリンダーの相対座標を入力することになります。原点からの相対座標は、アタッチ機能を使うことで簡単に取得することができます。
まず、シリンダーを選択した状態で[ホーム]タブ-[階層]-[アタッチ]をクリックします。
続いて、パレットを選択します。
これで、シリンダーが子、パレットが親の関係になりました。
この状態で、[コンポーネントプロパティ]ウィンドウからシリンダーの"座標"を"親"に変更すると、親コンポーネントであるパレットの原点を基点とした相対座標が表示されます。
これをそのまま"オフセット"にコピーします。以上で"オフセット"の設定ができました。
続いて"パターンカウント"を設定します。
個数はX方向に5個、Y方向に3個なので、"X:5","Y:3","Z:1"と入力します。
最後に"パターンステップ"を設定します。
シリンダーをクリックします。
[コンポーネントプロパティ]ウィンドウの[既定]タブを見ると、"CylinderRadius"、つまりシリンダーの半径が100mmと設定されています。
直径は2倍の200mmなので、ぴったり重なった製品同士の間隔は200mmとなります。
"パターンステップ"は、"X:200","Y:200"と入力します。
Z方向には1つしか製品を置かないため、Zは特に変更する必要はありません。
以上で、Cylinderの個数と配置の設定ができました。
シミュレーションを再生すると、シリンダーもパレットの上に順番に配置されていることが確認できます。
続いてTransportOutの設定を行います。
シミュレーションをリセットします。
まず、"TransportOut"をクリックして、[ステートメントプロパティ]ウィンドウから[目的地]を設定します。
フローステップに設定した次のプロセスへパレットを送る場合は「次のプロセスへ」を指定しますが、今回はコンベアの内部コンテナに直接送るので、"コンポーネントコンテナへ"を指定します。
コンベアの内部コンテナに製品が入ると、製品は自動でコンベア上を流れます。
また、[製品変数名]を"PalletPart"に変更します。
シミュレーションを再生します。運ばれてきたパレットの上に、製品が順番に乗せられていきます。
しかし、15個全て乗った後も、パレットはコンベア上を流れません。
理由は、パレットの上に乗った製品がパレットに取り付けられていないためです。
取り付けは自動的には行われないので、"アタッチ"ステートメントを使って取り付けを行う必要があります。
Loadingプロセスの、2つのTransportPatternInの下に、Attachを2つ追加します。
シミュレーションをリセットします。
3行目の"TransportPatternIn"をクリックして、"ステートメント"-"アタッチ"を2回クリックします。
まず一つ目のAttachではプレートをパレットに取り付けるように設定します。
4行目の"Attach"をクリックします。
[ステートメントプロパティ]ウィンドウから"親"は「PalletPart」、[子]は「PlatePart」と入力します。
二つ目のAttachではシリンダーをパレットに取り付けるように設定します。
5行目の"Attach"をクリックします。
"親"は「PalletPart」、"子"は「CylinderParts」"と入力します。
シミュレーションを再生します。
パレタイズ終了後、コンベア上を製品が流れていくようになりました。
このパレタイズのタスクをロボットや人間の作業者で行いたい場合は、人間やロボットとそのコントローラを配置して、トランスポートリンクにコントローラを設定します。
コントローラは[eカタログ]-[PM Transport Controller]の中にあります。
「デタッチを使用してデパレタイズしてみよう」では、デパレタイズの手法について紹介します。
以上で、「トランスポートインパターンを使用してパレタイズしてみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

トランスポートリンクツールを使用してみよう

製品のフローを設定するトランスポートリンクを一括削除、自動作成、コントローラー変更をする方法
https://youtu.be/3e8Zz29xiSA
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_145.zip

本動画では、プロセスモデリングにおけるトランスポートリンクについての説明と、トランスポートリンクツールの使い方について説明します。
初めに、「トランスポートリンクツールを使用してみよう.vcmx」を開きます。
[プロセス]タブ-[エディタ]-[プロセス]をクリックします。
作成するフローの流れとしては、製品が"Feeder"から"FromConveyor"に送られ、リソースを使用して"Stack"または"ToConveyor"に送られた後、"ToConveyor"を流れて、"Sink"で終了します。
[エディタ]-[フロー]をクリックします。
フローステップは、トランスポートリンクと一致させる必要があります。
製品フローを作成するには、3Dビューポートのプロセスラベルを使用してトランスポートリンクとフローステップを同時に定義する方法と、3Dビューポートでトランスポートリンクを定義し、フローステップを別で定義する方法があります。
例えば、多対多の接続を作成する場合、"FromConveyor"のプロセスラベルをクリックするとプロセスノードが選択され、プロセスノードの色が水色から黄色に切り替わります。
これは、プロセスラベルも選択されていることを意味し、フローステップにもプロセスラベルが追加されています。
次に、"Stack"のプロセスラベルをクリックすると、"FromConveyor"から呼び出されたすべてのプロセスが"Stack"のすべてのプロセスに接続されます。
"Human Transport Controller"をクリックし、"ToConveyor"のプロセスラベルをクリックすると、"Stack"の全てのプロセスが"ToConveyor"の全てのプロセスに接続され、部品の移動には人のリソースを使用します。
プロセスノードが選択状態のため、3Dビューポートの何もないスペースをクリックし、プロセスノードの選択を解除します。
[リンクを消去]ツールは、指定したリンクをまとめて削除することができます。
[トランスポートリンクツール]-[リンクを消去]をクリックすると、[リンクを消去]ウィンドウが表示されます。
[リンクを消去]ウィンドウから、"フローグループ"に、"Flow Group #1"を選択し、"リンクを消去"に"未使用"を選択します。
未使用のリンクとは、フローステップには使用されていないリンクを指します。
"ToConveyor"のプロセスラベルをクリックし、"Sink"のプロセスノードをクリックします。
プロセスノード自体をクリックすると、フローステップは作成されず、そのリンクはシミュレーションで使用されません。
[リンクを消去]ウィンドウの"消去"ボタンをクリックすると、先ほど追加した"ToConveyor"から"Sink"のリンクが消去されます。
次に、"リンクを消去"に"空"を選択します。
空のリンクとは、タスクを実行するためのリソースがないリンクを指します。
"Human Transport Controller"を削除し、[リンクを消去]ウィンドウの"消去"ボタンをクリックすると、リソースがない"Stack"から"ToConveyor"のリンクが消去されます。
"Human Transport Controller"を削除する前に戻します。
"リンクを消去"に"すべて"を選択し、消去ボタンをクリックすると、フローグループ内のすべてのリンクが消去されますが、フローステップのプロセスラベルは残ったままなので、プロセスラベルを全て削除します。
フローステップとトランスポートリンクを一致させるためには、3Dビューポートでの操作に注意が必要です。
特に、新たなプロセスラベルが作成された場合や、既存のプロセスラベルをクリックした場合には、そのフローが3Dビューポート内のフローと一致していることを確認する必要があります。
また、フローステップとトランスポートリンクを別々に作成することも可能です。
これは、一対一の接続や多対多の接続を作成する際に特に有用ですが、この場合でも、フローステップとトランスポートリンクが一致していることを確認する必要があります。
"FromConveyor"のプロセスノードを選択し、"Stack"のプロセスノード、"ToConveyor"のプロセスノードを順番に選択します。
フローステップにプロセスラベルが追加されないため、フローステップとトランスポートリンクを別々に作成できます。
3Dビューポートの何もないスペースをクリックし、プロセスノードの選択を解除します。
トランスポートリンクを作成する際には、一対多の接続や、多対一の接続も可能です。
一対多の接続を作成するには、まず"FromConveyor"のプロセスノードを選択し、"Stack"のプロセスラベルを選択します。
これにより、コンベヤーから各スタックへのリンクが作成されます。
逆に、多対一の接続を作成するには、プロセスラベルを選択してからプロセスノードを選択することで多対一のリンクが作成できます。
多対一の接続をする前の状態に戻します。
シミュレーションを実行する前に、作成したトランスポートリンクとフローステップが正しいかどうか確認します。
現在、フローステップには"Stack"しかないため、"FromConveyor"と"ToConveyor"を追加し、人のリソースが"FromConveyor"から"Stack"、"Stack"から"ToConveyor"へ部品を移動するように設定されていることを確認します。
シミュレーションを再生し、動作を確認します。
部品がどこにも移動せずに留まっている場合は、適切なトランスポートリンクが作成されていない可能性があります。
今回の場合、左二つのFromConveyorと、一番右以外の4つの"Stack"にはトランスポートリンクがないため、それぞれで部品が留まっています。
シミュレーションをリセットします。
[自動リンク]ツールは、3Dビューポート内のトランスポートリンクを自動的に作成できます。
これにより、一つ一つのリンクを手動で作成する手間を省くことができます。
[トランスポートリンクツール]-[自動リンク]をクリックすると、[自動リンク]ウィンドウが表示されます。
"フローグループ"に、"Flow Group #1"を選択し、"リンクを作成"ボタンをクリックすると、フローステップに基づいて足りないトランスポートリンクが作成されます。
"Sink"へのリンクがないため、"ToConveyor"のプロセスノードを選択し、"Sink"のプロセスラベルを選択します。
再度"リンクを作成"ボタンをクリックすると"Sink"への足りないリンクが作成されます。
[コントローラーを設定]ツールは、トランスポートリンクのコントローラーを一括で変更できます。
[トランスポートリンクツール]-[コントローラーを設定]をクリックすると、[コントローラーを設定]ウィンドウが表示されます。
"フローグループ"に、"Flow Group #1"を選択します。対象とするフローグループは"すべて"にもできます。
"プロパティ値をコピー"にチェックを入れると、"現在の実装者"と"新しい実装者"に同じプロパティがある場合に、"現在の実装者"のプロパティ値が、"新しい実装者"のプロパティに反映されます。
"ワークステートメントを含める"にチェックを入れると、プロセス内に作業ステートメントがある場合は、そこで使用されている"コントローラ"を変更できます。
"変更"ボタンをクリックすると、3Dビューポートでコントローラーが変更されています。
シミュレーションを再生すると、部品はプロセス間を自動で移動するようになりました。
以上で、「トランスポートリンクツールを使用してみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

ハンガーにワークを吊り下げて搬送しよう(1/2)

ハンガーにワークを吊り下げて搬送する方法
（Overhead Conveyorの設定、製品の在荷確認、フローの設定）
https://youtu.be/uvNED1z2tFA
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_157_p1.zip

ハンガーでワークを吊り下げ、搬送する方法について説明します。
設定が完了すると、ハンガーでワークを吊り下げ、コンベアの下部を移動する動作を表現できます。
本動画では、ハンガーがコンベア下部をループし、ワークがコンベア上を移動するように設定します。
付属ファイル「Work Hanging_before.vcmx」を開き、レイアウトを作成します。
ワークをハンガーで吊り下げるための、コンベアを配置します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Conveyors]-[Visual Compornents]から、[Overhead Conveyor]を3Dワールドにドラッグ＆ドロップします。
ハンガーの種類は製品タイプ「Hanger」として自動的に追加されます。
[Overhead Conveyor]の高さを変更します。
[コンポーネントプロパティ]ウィンドウの[既定]タブにある[ConveyorHeight]を「2900」に変更します。
角度を変更するため、座標Rzを180に変更します。
[Curve Conveyor]の形状を変更します。
Ctrlキーを押しながら、[Curve Conveyor]を2つ選択します。
[コンポーネントプロパティ]ウィンドウの[既定]タブにある[ConveyorAngle]を「180」に変更します。
コンベアを接続します。
[マニピュレーション]グループの[PnP]を選択し、[Curve Conveyor]を[Overhead Conveyor]に接続します。
[Conveyor]を[Curve Conveyor]に接続します。
シミュレーションを実行します。
ハンガーがコンベアの下部を流れていくことが分かります。
ハンガーを生成する間隔を変更できます。
シミュレーションをリセットします。
[Overhead Conveyor]を選択し、[コンポーネントプロパティ]ウィンドウの[HangerCreator]タブを展開します。
[間隔]を「5」に変更します。
シミュレーションを実行します。
ハンガーを生成する間隔が変更されたことが分かります。
[Overhead Conveyor]の支柱を自動で生成できます。
シミュレーションをリセットします。
[マニピュレーション]グループの[移動]を選択して、[Supports]を[Overhead Conveyor]の中央へ移動します。
[Overhead Conveyor]を選択し、[コンポーネントプロパティ]ウィンドウの[Supports]タブを展開します。
[Populate Supports]を選択します。
支柱が自動で生成されたことが分かります。
コンベアを移動します。
[Feeder]から生成される[Cylinder]を[Tube Geometry]に変更します。
製品を定義することで、[Feeder]から[Tube Geometry]を生成できます。
[プロセス]タブから[エディタ]グループの[製品]を選択します。
[製品タイプエディタ]ウィンドウにある[フローグループ番号1]を選択し、右クリックで削除します。
[フローグループを削除]のメッセージが表示されるため、[はい]を選択します。
[製品タイプエディタ]ウィンドウの[フローグループ番号2]を選択します。
[製品の定義]から[製品タイプを追加]を選択することで、[製品タイプ番号1]が追加されます。
[プロパティ]ウィンドウの[Name]を「Tube」に変更します。
[コンポーネントURI]右側の[Pick Component from 3D world]を選択します。
3Dワールドにある[Tube Geometry]を選択します。
Feederで生成するワークをTube Geometryに変更します。
[Feeder]を選択します。
[コンポーネントプロパティ]ウィンドウの[ProductCreator]タブから[パーツ]を展開し、[Tube]を選択します。
シミュレーションを実行します。
[Feeder]から[Tube Geometry]が生成されることが分かります。
ハンガーにワークを取り付けることで、ハンガーに吊り下げる表現ができます。
Geminiでは取り付けることをアタッチ、取り外すことをデタッチといいます。
ハンガーに在荷を確認するプロパティを追加します。
シミュレーションをリセットします。
[製品タイプエディタ]ウィンドウの[Hanger]を展開します。
[製品プロパティ]を選択し、右クリックでメニューを開きます。
[製品プロパティを追加]を選択することで、[プロパティ番号1]を追加できます。
[プロパティ]ウィンドウの[名前]を「Attach」に変更します。
[Type]を[Boolean]に変更します。
コンベアでワークを搬送できるように[To Conveyor Process #2]と[From Conveyor Process #2]をコンベアに接続します。
[マニピュレーション]グループの[PnP]を選択します。
[To Conveyor Process#2]を選択し、[Overhead Conveyor]の左端にドラッグ＆ドロップします。
[From Conveyor Process#2]を選択し、右側にある[Curve Conveyor]の手前側にドラッグ＆ドロップします。
[To Conveyor Process #2]にハンガーが到達後、ワークをアタッチできるように設定します。
ワークの準備ができていると、ハンガーにアタッチし、準備ができていないと、アタッチせずハンガーのみコンベアを流れます。
[To Conveyor Process #2]を選択します。
[ヘルパーツール]グループの[シグナルをクリエイト]を選択します。
[シグナルをクリエイト]ウィンドウの[シグナルタイプ]から[ブール型]を選択します。
シグナル名に「Signal」と入力します。
[シグナルをクリエイト]を選択します。
[出力]ウィンドウに[To Conveyor Process #2]にシグナルが追加されたことが表示されます。
[閉じる]を選択します。
シグナルが追加されたことを確認します。
[ホーム]タブの[接続]グループから[シグナル]を選択します。
シグナルエディタが表示され、シグナルが追加されたことが分かります。
ワークを搬送する流れを設定します。
[プロセス]タブから[エディタ]グループの[プロセス]を選択します。
中継地点の名前が重複していると、製品の流れを設定できないため、名前を変更します。
[Overhead Conveyor]に接続されている[ToConveyor]のプロセスラベルを選択し、プロセスを表示します。
[ルーチンプロパティ]ウィンドウの[名前]を、[ToConveyor_Over]に変更します。
プロセスを閉じます。
同様に[Curve Conveyor]に接続されている[FromConveyor]の名前を[FromConveyor_Over]に変更します。
[エディタ]グループから[フロー]を選択します。
[フロー]は製品を搬送する流れや、搬送方法を設定できます。
[プロセスフローエディタ]ウィンドウの[フローグループ番号2]を選択します。
[FromConveyor]、[ToConveyor_Over]、[FromConveyor_Over]、[ToConveyor]の順にプロセスラベルを選択します。
コンベアのプロセス間を輸送する方法を変更します。
現在、すべてのプロセス間をコンベアで輸送しています。
[FromConveyor]から[ToConveyor_Over]まで、[FromConveyor_Over]から[ToConveyor]までの輸送方法を変更します。
[FromConveyor]と[ToConveyor_Over]間のアイコンを選択します。
[プロパティ]ウィンドウの[インプリメンタ]を[InterpolatingTransport]に変更します。
InterpolatingTransportは、プロセス間の輸送を補間するコントローラーです。
輸送する時間を変更するため、[TransportTime]を「1」に変更します。
同様に右側のアイコンも、[InterpolatingTransport]に変更します。
[エディタ]グループの[フロー]を選択し、フローを非表示にします。
シミュレーションを実行します。
ハンガーとワークがコンベアを一周することがわかります。
シミュレーションをリセットします。
ハンガーがコンベア下部をループし、ワークがコンベア上を移動するように設定する方法についての説明は、以上となります。
ご視聴いただきありがとうございました。

=================================================================================

ハンガーにワークを吊り下げて搬送しよう(2/2)

ハンガーにワークを吊り下げて搬送する方法
（プロセスの設定）
https://youtu.be/l3HoUmTX8K0
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_157_p2.zip

ハンガーでワークを吊り下げ、搬送する方法について説明します。
本動画では、ハンガーでワークを吊り下げ、搬送するプロセスを設定します。
本動画は、ハンガーがコンベア下部をループし、ワークがコンベア上を移動するように設定する方法の続きから設定します。
ワークの流れが設定されたファイル「Work Hanging1_after.vcmx」が必要です。
[プロセス]タブの[エディタ]グループから[プロセス]を選択します。
[プロセス]は製品が移動する経路の中継地点の作業内容を設定できます。
[FromConveyor]のプロセスラベルを選択します。
ワークが[FromConveyor]に到達後、[ToConveyor_Over]のシグナルを「True」にします。
ワークを搬出し、シグナルをFalseにします。
[TransportIn]を選択します。
[ステートメント]を展開し、[その他のステートメント]から[シグナル送信]を選択します。
[シグナル送信]は、指定したシグナルの値を変更できます。
[ステートメントプロパティ]ウィンドウの[コンポーネント]から[To Conveyor Process #2]を選択します。
パート1で追加したシグナルを使用し、[FromConveyor]から[ToConveyor_Over]へワークを搬出するタイミングを判別します。
[シグナル]から[Transport]を選択します。
[値]に「True」と入力します。
[SendSignal]を選択し、コピーします。
[TransportOut]の後に貼り付け、[ステートメントプロパティ]ウィンドウの[値]を「False」に変更します。
プロセスを閉じます。
[ToConveyor_Over]のプロセスラベルを選択します。
シグナルが「True」になったとき、ワークを搬入します。
[TransportIn]を選択します。
ハンガーを[Overhead Conveyor]から搬入するため、[ステートメントプロパティ]ウィンドウの[ソース]を[コンポーネントコンテナから]に変更します。
[FromConveyor]からシグナルが送信されるまで待機するように設定します。
[ステートメント]を展開し、[その他のステートメント]から[シグナル待機]を選択します。
[シグナル待機]は特定のシグナルが条件を満たすまで次のステートメントを実行しません。
[ステートメントプロパティ]ウィンドウの[コンポーネント]から[To Conveyor Process #2]を選択します。
[シグナル]から[Transport]を選択します。
コンディションは、次のステートメントを実行する条件です。
今回は、空欄にすることで、どのような値でも次のステートメントを実行します。
トリガー待機は、シグナルの値の変化をトリガーとし、待機できます。
条件を、満たした瞬間のみ、次のステートメントを実行する場合、チェックを付けます。
条件を満たしている間、次のステートメントを実行する場合、チェックを外します。
今回は[トリガー待機]のチェックを外します。
シグナルを変数として使用するため、[出力値変数名称]に「Transport_var」と入力します。
シグナルが「True」のとき、ワークを搬入し、「False」のとき、ワークを搬入しないように設定します。
[ステートメント]を展開し、[フローコントロールステートメント]から[IF]を選択します。
[IF]は、条件に応じて実行する処理を変更できます。
シグナルはIF文の条件として使用できません。
[シグナル待機]で設定した変数「Transport_var」を使用します。
[ステートメントプロパティ]ウィンドウの[コンディション]に「Transport_var」と入力します。
「Transport」が「True」の場合、[Then]の範囲、「False」の場合、[Else]の範囲の処理を実行します。
[Then]の範囲を設定するため、[Then]を選択します。
「Transport」が「True」の場合、ワークを搬入しハンガーにワークをアタッチします。
ワークを搬入する位置を設定します。
[ステートメント]を展開し、[プロセスフローステートメント]から[トランスポートインパターン]を選択します。
[トランスポートインパターン]は、搬送するワークの位置や、個数を設定できます。
[ステートメントプロパティ]ウィンドウの[オフセット]の[Tx]に「-50」、[Tz]に「-1590」、[Rx]に「90」と入力します。
[パターンカウント]で搬入するワークの個数を設定します。
Y軸方向にワークを2つ搬入するため、[X]を「1」に変更します。
パターンステップでワーク同士の距離を設定します。
[Y]を「-400」に変更します。
搬入したワークの変数名を定義するため、[製品変数名]を「Tubes」に変更します。
ハンガーとワークをアタッチできるように設定します。
[ステートメント]を展開し、[プロセスステートメント]から[アタッチ]を選択します。
[アタッチ]は、親製品に子製品を取り付けることができます。
アタッチすることで親と共に子が移動します。
[ステートメントプロパティ]ウィンドウの[親]を「ProductIn」、子を「Tubes」に変更します。
ハンガーにワークをアタッチしたため、ハンガーの在荷プロパティ[Attach]の値を変更します。
[ステートメント]を展開し、[フローコントロールステートメント]から[変数を割り当てる]を選択します。
[変数を割り当てる]は、指定した変数の値を変更できます。
[ステートメントプロパティ]ウィンドウの[ターゲットプロパティ]に「ProductIn.Attach」、[数式値]に「True」と入力します。
「製品変数名.製品プロパティ名」という形で入力することで、搬入した製品の製品プロパティを取得できます。
[ProductIn]はハンガーの製品変数名です。
ハンガーの製品プロパティで設定した変数[Attach]を参照します。
[TransportOut]でワークがアタッチされたハンガーを搬出します。
[TransportOut]を選択し、[ステートメントプロパティ]ウィンドウの[製品変数名]が「ProductIn」であることを確認します。
プロセスを閉じます。
[FromConveyor_Over]のプロセスラベルを選択します。
ハンガーからワークを取り外すプロセスを作成します。
ハンガー搬入後、ワークがハンガーにアタッチされている場合、デタッチします。
[TransportIn]を選択し、[ステートメント]を展開します。
[フローコントロールステートメント]から[IF]を選択します。
[ステートメントプロパティ]ウィンドウの[コンディション]を「ProductIn.Attach」に変更します。
「True」の場合、ハンガーからワークをデタッチします。
[Then]を選択します。
[ステートメント]を展開し、[プロセスステートメント]から[デタッチ]を選択します。
[デタッチ]は、親製品から子製品を取り外すことができます。
[ステートメントプロパティ]ウィンドウの[製品変数名]が、[ProductIn]であることを確認します。
ProductInは、プロセスへ搬入した時につけたハンガーの名前です。
全てのワークを外すため、[多くをデタッチ]にチェックを付けます。
デタッチしたワークの名前を定義するため、[デタッチ変数名]を「Tubes」に変更します。
デタッチしたワークを搬出します。
[ステートメント]を展開し、[プロセスフローステートメント]から[トランスポートアウト]を選択します。
[ステートメントプロパティ]ウィンドウの[製品変数名]をデタッチで定義した「Tubes」に変更します。
[目的地]が[次のプロセスへ]であることを確認します。
ワークがハンガーからデタッチされるため、ハンガーに設定されているアタッチという変数の値を変更します。
[ステートメント]を展開し、[フローコントロールステートメント]から[変数を割り当てる]を選択します。
[ステートメントプロパティ]ウィンドウの[ターゲットプロパティ]に「ProductIn.Attach」、[数式値]に「False」と入力します。
ハンガーがコンベアを流れるように設定します。
一番下にある[TransportOut]を選択します。
[ステートメントプロパティ]ウィンドウの[目的地]を[コンポーネントコンテナへ]に変更します。
プロセスを閉じます。
シミュレーションを実行します。
ハンガーがワークを吊り下げた後、コンベアを流れ、ワークを搬出することが分かります。
シミュレーションをリセットします。
ハンガーでワークを吊り下げ、搬送する方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

ひとつのリソースが続けて作業を行うようにしてみよう

複数の作業やリソースがある場合、指定した作業をひとつのリソースが続けて行う方法（Human Transport ControllerのReserveResource、ReleaseResource）
https://youtu.be/ltze7SsrnVc
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_091.zip

本動画では、リソースにタスクを割り当てる方法について説明します。リソースにタスクを割り当てることで、タスク中に別のタスクの割り込みを防ぎ、ひとつのリソースが続けて作業を行うようにできます。
まず初めに、「ひとつのリソースが続けて作業を行うようにしてみよう.vcmx」を開きます。
プロセスフローを設定します。
[プロセス]タブ-[エディタ]-[フロー]をクリックします。
「Human Transport Controller」のひし形アイコンをクリックし、「Create」のプロセスラベル-「Sink」のプロセスラベルの順でクリックします。
シミュレーションを再生します。
作業者が「Create」で作業を行い、生成された製品は「Sink」へ輸送します。
この時作業者は、「Create」で作業を行った後、すぐに製品の輸送は行わず、別のプロセスへ移動しタスクをしてから製品を輸送しています。
これは、作業タスク中に別プロセスのタスクが作業者に割り当たり、その別プロセスのタスクを、作業中のタスクが終わった後に行ったからです。
作業者が作業タスクを開始してから製品の輸送タスクを完了するまで、別のタスクの割り込みを防ぐ方法を説明します。
リソースを制御するコントローラの"ReserveResource"シグナルを使用することで、リソースにタスクを割り当てることができます。
タスクを割り当てられたリソースは、タスクの割り当てが解除されるか別のタスクを割り当てられるまで、別プロセスのタスクの割り込みを防ぎ、同じプロセスで続けて作業を行うようになります。
「Process Node #2」の「Create」のプロセスラベルを右クリックします。
"Create:~"を選択した状態で、"ステートメント"-"シグナル送信"をクリックします。
追加した"SendSignal:~"をクリックし、[ステートメントプロパティ]ウィンドウから設定を変更します。
"コンポーネント"を"Human Transport Controller"、シグナルを"ReserveResource"に変更します
"ReserveResource"は、コントローラに接続しているリソースに、受信した"値"のプロセスコンポーネントのタスクを割り当てるシグナルです。
タスクを割り当てられたリソースは、タスクの割り当てが解除されるか、別のプロセスコンポーネントのタスクが割り当てられるまで、受信した"値"のプロセスコンポーネントのタスクのみを実行します。
タスクが割り当てられたリソースと同じトランスポートコントローラと接続している他のリソースには、受信した"値"のプロセスコンポーネントのタスクを割り当てることができません。
"値"には、割り当てたいタスクのプロセスコンポーネントの名前か、空文字列を設定します。空文字列を設定した場合、"シグナル送信"ステートメントを実行したプロセスコンポーネントの名前を値として使用します。
今回は、「Process Node #2」のタスクを割り当てるために、"値"に空文字列である""を設定します。
ここまでで、「Process Node #2」で製品ができた後に、作業者に「Process Node #2」のタスクを割り当てる設定ができました。
輸送タスクまで完了した後に、作業者のタスクが割り当てられた状態を解除するようにします。
リソースを制御するコントローラの"ReleaseResource"シグナルに値を送信することで、リソースのタスクの割り当てを解除することができます。
"SendSignal:~"をコピーして、"TransportOut:~"の次にペーストします。
ペーストした"SendSignal:~"をクリックして、"シグナル"を"ReleaseResource"に変更します。
送信する"値"には、"ReserveResource"と同様にプロセスコンポーネントの名前か、空文字列を設定します。
今回は、値に"""(空文字列)"を設定します。
これで「Process Node #2」では、製品ができてからその製品を輸送するまで、作業者にタスクを割り当てるようにできました。
シミュレーションを再生します。
「Process Node #2」の「Create」を実行する時、作業タスクと製品の輸送タスクの間に別のプロセスのタスクが割り込まなくなり、同じ作業者が作業タスクから製品の輸送タスクまで順番に行うようになりました。
以上で、「ひとつのリソースが続けて作業を行うようにしてみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

ビューエディタを使って視点を切り替えてみよう

3Dワールド上の視点の位置を保存し、切り替える方法（関連動画：録画する時のカメラの視点を設定しよう、録画する時カメラの視点をPythonで設定しよう）
https://youtu.be/S_1RPBmZy9M

本動画では、ビューエディタを使って、視点の保存や切り替えをする方法について説明します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Layouts]から"Machine Tending"をダブルクリックします。
"Machine Tending"が3Dワールド上にデフォルト位置で表示されます。
ビューエディタを使って、視点を設定します。
ビューエディタは、"3Dワールドツールバー"にあります。
"3Dワールドツールバー"-"ビューエディタ"をクリックします。
十字アイコンをクリックすると、現在の視点が"View"という名前で"ビューエディタ"に保存されます。
レイアウトを保存すると、ビューエディタの設定も保存されます。
ビューエディタに視点を保存したら、マウス操作で3Dワールドの視点を切り替えます。
[ファイル]タブ-[保存]をクリックして、レイアウトを保存します。
CtrlキーとNキーを押下し、一度3Dワールドを初期化して、先ほど保存したファイルを再度開きます。
"3Dツールバー"-"ビューエディタ"をクリックします。先ほど作成した"View"が保存されていることと、"View"をクリックすると3Dワールドの視点が切り替わることを確認します。
"ビューエディタをピン／ピンを解除"アイコンについて説明します。
"ビューエディタ"を表示中に、ピン解除状態で3Dワールド上の操作を行うと、"ビューエディタ"は閉じられます。
3Dワールド上での操作後も"ビューエディタ"が表示されることはありません。
そこで、"ビューエディタ"の"ビューエディタをピン／ピンを解除"アイコンをクリックします。
この操作を行うことで、3Dワールド上の操作を行った後に、"ビューエディタ"が表示されます。
"ビューエディタをピン／ピンを解除"アイコンを再度クリックすると、ピン状態を解除します。
保存されている視点のアップデートについて説明します。
マウス操作で視点を切り替えて、"ビューエディタ"の十字アイコンをクリックし、"View2"を追加します。
ビューの名称は、名称部分をクリックすることで変更できます。
"アップデート"は、選択しているビューに現在の視点を上書きする機能です。マウス操作で視点を切り替えて、"View2"の"アップデート"アイコンをクリックします。
"View2"の視点が更新され、現在の視点が"View2"に保存されます。
また、"削除"アイコンをクリックすると、選択しているビューを削除します。
以上で、「ビューエディタを使って視点を切り替えてみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

プロセスの中からロボットを動かしてみよう

ロボット以外のプロセスから、ロボットのプログラムを実行する方法
https://youtu.be/xvKq0VKiRgk
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_098.zip

本動画では、プロセス実行中にロボットルーチンを呼び出して、ロボットを動かす方法について説明します。
プロセス実行中にロボットルーチンを呼び出すには、"ロボットルーチンを起動"ステートメントを使用します。
初めに、「プロセスの中からロボットを動かしてみよう.vcmx」を開きます。
このレイアウトに、ロボットを追加します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Robots]-[Visual Components]から、「Generic Articulated Robot」を3Dワールドにドラッグ&ドロップします。
「Generic Articulated Robot」にロボットルーチンを定義します。
[プログラム]タブに移動します。
[プログラムエディタ]ウィンドウ-"サブプログラム"-"シーケンスを追加"をクリックします。
追加された"Sequence1"を選択した状態で、[ルーチンプロパティ]ウィンドウから、[名前]を「Moving」に変更します。
「Moving」にステートメントを追加して、ロボットの動作を定義します。
今回は"各軸補間ステートメント"を追加します。
"各軸補間ステートメント"は、位置を定義し、その位置に到達できるようにロボットが動くステートメントです。
[マニピュレーション]-[ジョグ]が選択されていることを確認して、「Generic Articulated Robot」の先端をドラッグして位置を変更し、"各軸補間ステートメント"をクリックします。
位置を変更して、"各軸補間ステートメント"を追加します。
これを繰り返して、「Moving」に合計4つの"各軸補間ステートメント"を追加します。
これで、「Generic Articulated Robot」にロボットルーチンが定義できました。
次に、プロセスにステートメントを追加して、プロセス実行中にロボットルーチンを呼び出すようにします。
[プロセス]タブに移動します。
[エディタ]-[プロセス]をクリックし、3Dワールド上の"Process #1"をクリックします。
"SendSignal:False~"を選択した状態で、"ステートメント"-"ロボットルーチンを起動"をクリックします。
追加された"RunRobotRoutine:~"をクリックし、[ステートメントプロパティ]ウィンドウを開きます。
"ロボットルーチンを起動"ステートメントは、"コンポーネント"に設定したロボットの、"ルーチン名称"のロボットルーチンを実行させるステートメントです。
[コンポーネント]に「Generic Articulated Robot」、[ルーチン名称]を「"Moving"」に変更します。
[ルーチン名称]はダブルコーテーションマークで挟んで記述してください。
ダブルコーテーションマークがない場合、設定した値は、文字列ではなくプロパティ名として処理されてしまいます。
シミュレーションを再生します。
「Process Node」に製品が搬入されると、"RunRobotRoutine:~"が実行され、「Generic Articulate Robot」の"Moving"が呼び出されて、ロボットが動きます。
以上で、「プロセスの中からロボットを動かしてみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

ライブラリ製品を使って倉庫をモデリングしてみよう

eカタログを組み合わせて、倉庫を作る方法
（「Warehouse Shelf」「Warehouse Process Shelf」「Floorspace Buffer」「Single Girder Crane」「Dual Rail Transport Controller」「Stack Feeder」「Pallet Feeder」。関連動画：自動倉庫を作ってみよう）
https://youtu.be/oXsWdSpwwok
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_129.zip

本動画では、ラックをモデリングする時に使用するコンポーネントについて説明します。
はじめに、「Warehouse Shelf」について説明します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Warehousing]から「Warehouse Shelf」を3Dワールド上にドラッグ&ドロップします。
「Warehouse Shelf」は、複数の製品を一時保管して、並行して出し入れさせることができます。
棚の外見、段数や大きさなどのサイズに関するプロパティは、[既定]タブから設定できます。
[既定]タブについて説明します。
"Presets"は、棚の外見の設定です。
この設定を変更する時にラックのサイズも変わる場合、確認のダイアログが出力します。
各部位の表示・非表示の切り替えは、[Option]タブで設定できます。
[既定]タブに戻ります。
"Tiers"は、段数の設定です。
"Bays"は、1段あたりの間口の数の設定です。
"BaysPerSupportBeam"は、ラックを区切る柱を間口何個に対して1つ配置するかの設定です。
設定した値が、"Bays"を割った時に小数点が生じる値の場合、コンポーネントのレイアウトが崩れてしまいます。
設定する値は、"Bays"の約数にしてください。
"BayWidth"は、間口1個当たりの幅の設定です。
"BayDepth"は、間口1個当たりの奥行きの設定です。
"BayHeight"は、間口1個当たりの高さの設定です。
"BayTilt"は、棚板の傾きの設定です。
"FrameWidth"は、正面から見た時の柱の幅の設定です。
"FrameThinkness"は、柱の奥行きの設定です。
"BeamsHeight"は、ラックの梁の厚さの設定です。
"FloorClearance"は、最下段の床と地面との距離の設定です。
"ProductOrientation"は、製品がラックに置かれる時の角度の設定です。
"FlowInResourceLocation/FlowOutResourceLocation"は、リソースが製品をラックに入れる/ラックから製品を取り出す時の位置です。
リソースが"Stacker Crane"の場合は適応されません。
3Dワールド上の表示はそれぞれ1つだけですが、この設定は全てのラックに対して適応されます。
"ShowResourceLocation"は、3Dワールド上の"FlowInResourceLocation/FlowOutResourceLocation"の表示/非表示の設定です。
チェックを外して非表示にした場合でも、"FlowInResourceLocation/FlowOutResourceLocation"の設定は有効です。
[既定]タブの説明は以上になります。
次に、"Warehouse Shelfに記述されているプロセスについて説明します。
[プロセス]タブ-[エディタ]-[プロセス]をクリックし、"Buffer"のプロセスラベルをクリックして、"Buffer"ステートメントをクリックします。
"Buffer"ステートメントは、ラックへ入れる製品の種類やラックへ製品を入れる、またはラックから製品を取り出す時の順番などの設定を行います。
"AcceptAllProductTypes"は、受け入れる製品タイプについての設定です。チェックがついている場合は全ての製品タイプを受け入れることができます。
チェックを外し、"AcceptedProductTypes"や"AcceptedFlowGroups"を設定することで、受け入れる製品タイプを指定できます。
"BufferFeedMode"は、ラックに入っている製品をどこのラックから取り出すかの設定です。
"BufferNeedMode"は製品をラックへ入れる時に、どのラックへ入れるかの設定です。
"FIFO"はラックに入った順に製品を取り出します。
"LIFO"はラックに入った順の逆順で製品を取り出します。
"ClosestToZeroPosition"は、"ZeroPositionNode"に設定したコンポーネントに近い位置にあるラックから順に処理を行います。
画面では、"ZeroPositionNode"に"Cylinder"を設定しています。
"Chaotic"はランダムで処理を行います。
"LinerOrder"はラックの最下段から1段ごとに順番に製品を入れます。
"RandomStream"は、"BufferFeedMode"または"BufferNeedMode"が"Chaotic"の時に使用する、乱数生成時のシード値です。
同じシード値を指定した場合、毎回同じ計算がされます。
ZeroPositionNode"は、"ClosestToZeroPosition"を使用する時の基準とするコンポーネントを3Dワールド上のコンポーネントから選択して設定します。
"ParallelInput/OutputLimit"は、同じプロセスフローに複数のラックが接続されていた場合、使用するラックを切り替えるまでに処理できる製品の数の設定です。
ラックの総容量以下の数値を設定します。
Warehouse Shelf の説明は以上になります。
次に、"Floorspace Buffer"について説明します。
"Warehouse Shelf"を削除します。
[eカタログ]ウィンドウ-[タイプ別モデル]-"PM Warehousing"から"Floorspace Buffer"を3Dワールド上にドラッグ&ドロップします。
このコンポーネントは、外見以外は"Warehouse Shelf"とほぼ同じです。
"Warehouse Shelf"はサイズが大きくなると高さが大きくなるのに対し、"Floorspace Buffer"は面積が大きくなります。
"Floorspace Buffer"の固有のプロパティについて説明します。
"Rows"は、棚の行数の設定です。
"Columns"は、棚の列数の設定です。
"SlotWidth"は、棚1つの幅の設定です。
"SlotLength"は、棚1つの長さの設定です。
"SlotWidthSpacing"は、棚の行間の長さの設定です。
"SlotLengthSpacing"は、棚の列間の長さの設定です。
"LineWidth"は、棚1つの縁の幅の設定です。
"Floorspace Buffer"の説明は、以上になります。
次に、"Warehouse Process Shelf"について説明します。
"Floorspace Buffer"を削除します。
[eカタログ]ウィンドウ-[タイプ別モデル]-"PM Warehousing"から"Warehouse Process Shelf"を3Dワールド上にドラッグ&ドロップします。
"Warehouse Process Shelf"は、複数の製品を同時に処理するためのコンポーネントです。
[コンポーネントプロパティ]ウィンドウで設定する内容は、"Warehouse Shelf"と同じです。
"Warehouse Process Shelf"の固有のプロパティについて説明します。
[プロセス]タブ-[エディタ]-[プロセス]を選択して、"ProcessBuffer"をクリックします。
"ProcessBuffer"ステートメントのプロパティについて説明します。
"AcceptAllProductTypes"から"ParallelOutputLimit"までと"RandomStream"は、先ほどの"Warehouse Shelf"の"Buffer"ステートメントと同じです。
"ProcessTime"は、棚に置かれた製品の処理時間を設定します。棚に置かれ、"ProcessTime"で設定した時間経過した製品は、この後に設定された処理を行うことが可能です。
"MaximumStoringTime"は、この棚にある製品が"OutdatedProductType"に設定した製品タイプに変更されるまでの時間を設定します。
0以外が設定されている時に有効になります。
「Warehouse Process Shelf」に格納され、"ProcessTime"秒経過後、さらに"MaximumStoringTime"秒経過後も「Warehouse Process Shelf」に残っていた製品は、"OutdatedProductType"に設定した製品タイプに変更されます。
"MaximumStoringTime"と"OutdatedProductType"のプロパティを設定することで、時間経過で劣化した製品などを表現できます。
画面では、時間経過で劣化した製品は、黄色になるように設定しています。
"FailedProductPercentage"は、不良品になる確率を設定します。
不良品になった場合、製品タイプは"FailedProductType"で設定した製品タイプに変更されます。
"FailedProductPercentage"と"FailedProductType"を設定することで、不良品を表現できます。
画面では、20％の確率で、赤色の不良品になるように設定しています。
"Warehouse Process Shelf"の説明は、以上になります。
次に、"Dual Rail Transport Controller"について説明します。
"Warehouse Process Shelf"を削除します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Transport Controllers]から"Dual Rail Transport Controller"をダブルクリックします。
このコンポーネントは、クレーンを制御するコントローラです。クレーンの線路・滑走路としても機能します。最大2つのクレーンを同時に接続できます。
[eカタログ]ウィンドウ-[タイプ別モデル]-"PM Cranes"から"Single Girder Crane"と"Double Girder Crane"をダブルクリックします。
[ホーム]タブ-[マニピュレーション]-[PnP]を選択した状態で、クレーンをコントローラ上にドラッグ&ドロップすることで、接続できます。
クレーンが接続されると、自動的にクレーンのサイズを調整します。
また、コントローラを移動させると、接続したクレーンも一緒に移動します。
"Dual Rail Transport Controller"をクリックして、[コンポーネントプロパティ]ウィンドウを表示します。
[既定]タブについて説明します。
"RunwayLength"は、クレーンの滑走路の長さの設定です。
"RunwaySpan"は滑走路の間の長さの設定です。
"RunwayHeight"は、滑走路の高さの設定です。
"RailWidth"は、レールの幅の設定です。
"RailHeight"は、レールの高さの設定です。
"AmountOfSupports"は、滑走路を支える柱の数の設定です。2-10の値を設定します。
"SafetyClearance"は、クレーンが2台接続していた際にクレーン同士がぶつからないように設定する、クレーン間で最低限空いてないといけない間隔の設定です。
"CheckLimits"は、クレーンがコントローラの軌道から外れた時に、シミュレーションを一時停止してエラーを出力するようにする機能です。
"Auto Configure Links"をクリックすると、複数のクレーンがレールに接続されている場合、リンクのソースノードと目的地ノードに、クレーンAとクレーンBのどちらか近い方をそれぞれ関連付けます。
[LinkDefaults]タブの各プロパティ値は、トランスポートリンクにこのコントローラを割り当てられます。
設定値については、後程説明します。
なお、この設定は、トランスポートリンクのプロパティから"UseCustomParameters"を有効にした場合に、デフォルト値として使用する値です。
次に、"Dual Rail Transport Controller"をトランスポートリンクに割り当てた時のプロパティについて説明します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Flow Components]から、"Feeder Process"と"Sink Process"を3Dワールド上にドラッグ&ドロップします。
[プロセス]タブ-[エディタ]-[フロー]をクリックします。
"Dual Rail Transport Controller"上のひし形アイコンをクリックし、Feeder-Sinkの順にクリックします。
"Dual Rail Transport Controller"をトランスポートリンクに割り当てたフローが設定できました。
Feeder-Sink間のひし形アイコンをクリックします。
プロパティについて説明します。
"Priority"は、優先度の設定です。1～100の数字を設定します。値が小さいほど、優先度は高くなります。
"Use Crane"は、輸送に使用するクレーンを指定します。
Anyの場合は、利用可能なクレーンの中で、製品の搬入地点に近いクレーンを使用します。
"WaitForNextTransport"は、トランスポートイン開始ステートメントや、トランスポートアウト開始ステートメントを使って製品を輸送する時に、トランスポート待機ステートメントが実行されるまで、クレーンにタスクを割り当てた状態で待機させる機能です。
"LoadAssist"は、クレーンが製品をつかむ時に、その作業を補助するリソースを設定します。
"UnloadAssist"は、クレーンがつかんでいる製品を離す時に、その作業を補助するリソースを設定します。
この2つに設定する値は、リソースを制御するコントローラーを設定してください。
画面では、"LoadAssist"に"Human Transport Controller"を設定しています。
輸送の時間などは、"GraspTime"以降のプロパティで設定しています。
これらの値はコントローラの"LinkDefault"タブの値を初期値として使用しています。
これらのプロパティを変更するには、"UseCustomParameters"を有効にする必要があります。
"GraspTime"は、クレーンが製品を掴むまでにかかる時間の設定です。
"ReleaseTime"は、それぞれクレーンがつかんでいる製品を離すまでの時間の設定です。
この二つの時間の設定には、作業を行う際のアームの伸縮にかかる時間は含まれません。
"GraspForm"は、製品をつかむ際に、製品のどの位置からつかむかの設定です。
"PickApproach"は、製品を積み込む作業位置へ移動する時の、中継地点の設定です。輸送元の"ResourceLocation"を基準とします。
"PlaceApproach"は、製品を降ろす作業位置へ移動する時の、中継地点の設定です。輸送先の"ResourceLocation"を基準とします。
"Dual Rail Transport Controller"の説明は、以上になります。
次に、Dual Rail Transport Controllerに接続するクレーンについて説明します。
Dual Rail Transport Controllerには、天井クレーンを接続します。
天井クレーンは、PM Cranesに5種類登録されています。構造やサイズは異なりますが、特性や動作は同じです。
今回は、"Single Girder Crane"を使って、天井クレーンのプロパティについて説明します。
"BridgePosition"は、クレーンがコントローラの滑走路上のどの位置にあるかの設定です。
"Gripper"は、クレーンのグリッパーの位置の設定です。
"Single Girder Crane"は、製品の輸送にグリッパーを使用しません。
そのため、初期設定では、グリッパー部分のフィーチャ(Block_4、Block_4_1)が非表示になっており、[既定]タブの"Gripper"の値を変更しても、見た目は変化しません。
"TrolleyPosition"は、クレーンのフックがトロリー上のどの位置にあるかの設定です。
"HoistPosition"は、クレーンのフックの位置の設定です。
"Hook"は、クレーンのフックの向きの設定です。
"SlingLength"は、クレーンのフックから製品までのオフセットの設定です。
[RailWidth]は、クレーンのレールの幅の設定です。
"BridgeWidth"は、クレーンのサドルの幅の設定です。
"BridgeLength"は、クレーンのレールの長さの設定です。
"BridgeRailHeightは、クレーンのレールの高さの設定です。
"TrolleyLength"は、クレーンのトロリーの奥行きの設定です。
"AutoHoming"タブは、クレーンがアイドル状態になった時にホームポジションに戻る"AutoHoming"機能についての設定を行うタブです。
"Delay"は時間を定義します。アイドル状態が"Delay"秒続いたら、ホームポジションへ移動します。
"BridgePosition"、"TrolleyPosition"、"HoistPosition"は、ホームポジションとなる各軸の位置を設定します。
"ReadCurrentJointValues"は、現在の位置を読み取り、"BridgePosition"、"TrolleyPosition"、
"HoistPosition"を設定する機能です。
"Speeds"タブでは、各ジョイントのキネマティックパラメータを設定します。
加速度であるAccelerationは、減速度にも使用されます。
クレーンの説明は、以上になります。
次に、"Stack Feeder"について説明します。
レイアウトを一度初期化します。
[eカタログ]ウィンドウ-[タイプ別モデル]-"PM Warehousing"から、"Stack Feeder"を3Dワールド上にドラッグ&ドロップします。
"StackFeeder"は、複数の製品をスタックして生成するコンポーネントです。初期設定では、パレットをスタックします。
[既定]タブの設定は、他のプロセスコンポーネントと同じです。
[コンポーネントプロパティ]ウィンドウ-"Stack"タブでは、生成時の設定が定義されています。
"Count"は、一度に生成する製品の数の設定です。スタックの段数になります。
"Step"は、製品間の垂直方向の間隔の設定です。
"PalletStep"は、最下段の製品とその1つ上の製品間の垂直方向の間隔の設定です。
"Delay"は、次のスタックしたパレットを生成するまでのインターバルの設定です。
"StackFeeder"のプロセスについて説明します。
[プロセス]タブ-[エディタ]-[プロセス]をクリックし、"StackFeeder"をクリックします。
製品を1つずつ積んで、1つの製品を生成する処理が記述されています。
動作を確認します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Conveyors]からConveyorを3Dワールド上にドラッグ&ドロップします。
[マニピュレーション]-[PnP]を選択した状態で、ConveyorをStack Feederに近づけ、接続します。
シミュレーションを再生します。スタックされたパレットが生成され、コンベア上を流れます。
"Stack Feeder"の説明は以上になります。
最後に、"Pallet Feeder"について説明します。
"Stack Feeder"を削除します。
[eカタログ]ウィンドウ-[タイプ別モデル]-"PM Warehousing"から、"Pallet Feeder"を3Dワールド上にドラッグ&ドロップします。
"Pallet Feeder"は、"Stack Feeder"と同じく、製品を積まれた状態で生成するコンポーネントです。
このFeederは、"Stack"タブとPythonScriptを使ってプロセスの制御をしています。
"Stack"タブの設定は、"StackFeeder"と同じです。
[エディタ]-[プロセス]を選択した状態で"Pallet Feeder"をクリックします。
このプロセスの場合、最初のWhileで複数段に積まれた製品を作成し、最後のWhileで積まれた製品を最下段から1つずつコンベアへ搬出する処理が記述されています。
動作を確認します。
[マニピュレーション]-[PnP]を選択した状態で、ConveyorをドラッグしてPallet Feederに近づけ、接続します。
シミュレーションを再生します。
複数のパレットが積まれた状態で生成され、最下段から1つずつコンベア上を流れます。
以上で、「ライブラリ製品を使って倉庫をモデリングしてみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

ラインシミュレーションで製品を削除しよう

ラインシミュレーション上で流れる製品を、途中で削除する方法（Sink Process、製品削除）
https://youtu.be/1QPNKRbPVtk
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_137.zip

ラインシミュレーションで、シミュレーション中に製品を削除する方法について説明します。
付属ファイル「ProductDelete_before.vcmx」を開きます。
eカタログのSink Processを使用することで、製品を削除できます。
ロボットで、Feeder ProcessからSink Processへ製品を搬送し、製品を削除します。
製品を搬送するため、フローを設定します。
[プロセス]タブをクリックします。
[エディタ]グループの[フロー]を選択することで、製品を搬送する流れを設定できます。
3Dワールドに表示された青い丸をプロセスノード、青い丸にカーソルを合わせると表示される名前をプロセスラベルと言います。
プロセスノードは、製品を搬送する経路の中継地点、プロセスラベルは中継地点の名前です。
[プロセスフローエディタ]ウィンドウのフローグループ番号1を選択します。
製品を、[Feeder]から[Sink]へ、ロボットで搬送するため、3Dワールドで、ロボットコントローラーアイコンをクリックします。
製品を搬送するためには、3Dワールドと、[プロセスフローエディタ]ウィンドウの両方にフローを設定する必要があります。
[Feeder]、[Sink]の順にプロセスラベルをクリックします。
3Dワールドに、[Feeder]から[Sink]の方向を指し示す矢印が表示されていることを確認します。
[プロセスフローエディタ]ウィンドウの[フローステップ]にも、[Feeder]、[Sink]の順に表示されています。
プロセスラベルをクリックすることで、3Dワールドと[プロセスフローエディタ]ウィンドウの両方にフローを追加できます。
プロセスノードをクリックすることで、3Dワールドにのみフローを追加できます。
シミュレーションを実行します。
Sink Processに搬送された製品が、削除されることがわかります。
コンベア上を移動完了した製品を削除する方法について説明します。
シミュレーションをリセットします。
Sink Processとコンベアを接続するため、[マニピュレーション]グループの[PnP]を選択します。
Sink Processを選択し、Conveyorの端にドラッグします。
Sink Processに表示されている三角形が、1つ緑に変化することを確認します。
搬送先の位置を調整するため、Sink Process、To Conveyor Process、Conveyorをすべて選択します。
コントロールキーを押した状態で、選択することで、複数個同時に選択できます。
[マニピュレーション]グループの[移動]を選択し、-X軸方向に矢印をドラッグします。
製品を搬送するフローを変更します。
[エディタ]グループから[フロー]を選択します。
3Dワールドに表示されているフローを選択し、右クリックから、[削除]を選択します。
フローの順番は、Feeder、ToConveyor、Sinkです。
ロボットが、FeederからToConveyorへ搬送するため、ロボットコントローラーアイコンを選択します。
プロセスノードをクリックし、3Dワールドにフローを追加します。
Sinkをクリックする前に、ロボットコントローラーアイコンの選択を解除します。
[プロセスフローエディタ]ウィンドウの[フローステップ]にもフローを追加する必要があります。
ToConveyorのプロセスノードにカーソルを合わせ、表示されたプロセスラベルを、[フローステップ]のFeederとSinkの間にドラッグ＆ドロップします。
FeederからSinkへの搬送と異なり、製品はコンベア上を通るため、Sinkのプロセスを変更します。
[エディタ]グループの[プロセス]を選択することで、プロセスノードで行う作業内容を設定できます。
[Sink]を選択します。
Sinkでは、製品を搬入し、削除しています。
TransportInを選択し、[ステートメントプロパティ]ウィンドウの[ソース]を[コンポーネントコンテナから]に変更します。
[コンポーネントコンテナから]にすることで、コンベア等のコンテナから製品を搬入できます。
シミュレーションを実行します。
製品は、コンベア上を移動し、削除されることがわかります。
製品がコンベア上を移動完了後、削除されるまで、指定した時間待機する方法を説明します。
シミュレーションをリセットします。
Sinkのプロセスを表示します。
TransportInとRemoveの間に遅延を発生させます。
TransportInを選択します。
プロセスエディタ右上の[ステートメント]をクリックし、ステートメント一覧を表示します。
[その他のステートメント]から[ディレイ]を選択します。
[ディレイ]ステートメントは、次のステートメントの実行を指定した時間、遅延させることができます。
[ステートメントプロパティ]ウィンドウの[分布]で、遅延させる時間を指定できます。
[分布]を5に変更します。
シミュレーションを実行します。
製品は、Sink Processに到達し、5秒待機後、削除されます。
製品の削除は、Sink Process以外でも行うことができます。
製品を、Feeder ProcessからManual Workstationへ搬送し、削除します。
シミュレーションをリセットします。
製品を搬送するフローを変更するため、[エディタ]グループの[フロー]を選択します。
3Dワールドと[プロセスフローエディタ]ウィンドウで、既存のフローをすべて削除します。
ロボットコントローラアイコンを選択し、Feeder、ManualProcessの順にプロセスラベルをクリックします。
3Dワールドと[プロセスフローエディタ]ウィンドウに、フローが追加されたことを確認します。
Manual Workstationのプロセスを変更します。
[エディタ]グループの[プロセス]を選択します。
[ManualProcess]と[Sink]をクリックします。
ManualProcessの既存のステートメントをすべて削除します。
Sink Processのステートメントをコピーし、貼り付けます。
ManualProcessのTransportInを選択し、[ステートメントプロパティ]ウィンドウで[ソース]を[前のプロセスから]に変更します。
ManualProcessとSinkを閉じます。
シミュレーションを実行します。
ロボットが、Feeder ProcessからManualWorkStationへ製品を搬送し、5秒後、製品は削除されます。
シミュレーションをリセットします。
複数の製品をManualWorkStationへ搬送し、5秒後、すべての製品を同時に削除します。
[エディタ]グループの[プロセス]を選択します。
ManualProcessを表示します。
複数の製品を搬入するため、TransportInを削除します。
ステートメント一覧から、[トランスポートインパターン]を追加します。
[トランスポートインパターン]は、指定した個数、製品を搬入完了するまで、待機できます。
TransportPatternInをDelayの上に移動させます。
製品を搬入する位置を調整します。
[ステートメントプロパティ]ウィンドウの[オフセット]で、最初に搬入する位置を変更できます。
[Tx]と[Ty]に-50と入力します。
[パターンカウント]で、搬入する個数を指定できます。
今回は変更せず、2×2×1の合計4個搬入します。
[パターンステップ]で、前に搬入した製品と、次に搬入する製品の距離を変更できます。
[X]と[Y]に150、[Z]に0と入力します。
[製品変数名]で搬入したすべての製品に、同じ名前を定義します。
Removeは、製品変数名を指定して、製品を削除するため、搬入した製品を一括で削除できます。
シミュレーションを実行します。
ロボットが製品を搬送します。
ManualWorkStationに4個搬入が完了し、5秒後、すべての製品が同時に削除されることがわかります。
シミュレーションをリセットします。
ラインシミュレーションで、シミュレーション中に製品を削除する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ランダムで不良品・故障が発生するようにしよう

ランダムで不良品や故障が発生するように設定する方法。(IFステートメント、uniform関数)
https://youtu.be/yOExrYWJh6k
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_154.zip

本動画では、シミュレーション中にランダムで不良品・故障が発生するようにする方法を説明します。
初めに、「ランダムで不良品・故障が発生するようにしよう.vcmx」を開きます。
シミュレーションを再生します。製品が生成され、装置やコンベアへ輸送しています。
このレイアウトに①ランダムで赤色の不良品が発生する。不良品の場合、装置には入れず廃棄する。②ランダムで装置が故障する。故障した場合は、作業者が復旧作業を行う。ように設定します。
まず、不良品を製品タイプに追加します。
シミュレーションをリセットします。
3Dワールド上の「Cylinder」をクリックして、コピー&ペーストします。
「Cylinder #2」をクリックした状態になっているので、[コンポーネントプロパティ]ウィンドウから[マテリアル]を「red」に変更します。
[プロセス]タブ-[エディタ]-[製品]をクリックします。
[製品タイプエディタ]ウィンドウで"フローグループ番号1"をクリックし、"製品の定義"-"製品タイプを追加"をクリックします。
"製品タイプ番号1"をクリックします。
[プロパティ]ウィンドウから[名前]を「不良品」に変更します。
"Pick component from 3D world"をクリックし、3Dワールド上の「Cylinder #2」をクリックします。
これで、不良品を製品タイプに追加できました。
次に、製品を生成する時に、ランダムで不良品が生成されるようにします。
[エディタ]-[プロセス]をクリックします。
"Feeder"をクリックします。
"ステートメント"-"IF"をクリックします。追加された"IF~"を先頭に移動します。
IFステートメントの条件式には、「乱数を生成し、その値が25以上ならTrue、25未満ならFalse」となるように設定します。
[ステートメントプロパティ]ウィンドウから[コンディション]を「uniform(0,0,100) > 25」に変更します。
uniform関数は、第二引数以上第三引数未満の範囲での一様分布です。
今回の場合、0以上100未満の一様分布となります。
第一引数は、Streamです。
Streamが同じ場合、シミュレーションをリセットして再度実行しても、同じ乱数セットを生成できます。
"Then"には、条件式がTrueの場合の処理を記述します。
今回の場合、良品を生成する処理を記述します。
"Create:~"をドラッグして、"Then"の下に移動します。
"Else"には、条件式がFalseの場合の処理を記述します。
今回の場合、不良品を生成する処理を記述します。
"Create:~"をコピー&ペーストして、"Else"の下に追加します。
"Else"の"Create:~"をクリックします。
[ステートメントプロパティ]ウィンドウから"製品タイプ"を"不良品"に変更します。
これで、ランダムで不良品が生成されるようになりました。
次に、不良品が発生した時に、装置には移動させずに廃棄するようにします。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Flow Components]から"Sink Process"を3Dワールド上にドラッグ&ドロップします。
[エディタ]-[フロー]をクリックします。
"フローグループ番号1"に"FromConveyor"-"Sink"を設定します。
トランスポートリンクには"Human Transport Controller"を割り当てます。
良品と不良品は、同じフローグループで定義されているので、このままでは、不良品が装置へ輸送されたり、良品が廃棄されてしまいます。
フィルター機能を使って、不良品を装置へ移動したり、良品を廃棄したりしないようにします。
"Parametric Lathe"をクリックします。
"TransportIn:~"をクリックして、[ステートメントプロパティ]ウィンドウから"製品フィルター"を展開します。
"製品タイプ"-"使用可能な製品タイプ"を"良品"に変更します。
チェックボックスにチェックを入れて、"製品タイプ"フィルターを有効にします。
これで、良品のフィルターが設定できました。
"Sink"をクリックします。
"TransportIn:~"をクリックして、[ステートメントプロパティ]ウィンドウ-"製品フィルター"-"製品タイプ"-"使用可能な製品タイプ"を"不良品"に変更します。
チェックボックスにチェックをいれて、"製品タイプ"フィルターを有効にします。
これで、不良品のフィルターが設定できました。
ここまでで、ランダムで不良品が生成されるようになり、良品の場合は装置へ、不良品の場合は廃棄されるようになりました。
シミュレーションを再生します。
ランダムで不良品が生成されるようになり、不良品の場合はSinkへ運ぶようになりました。
次に、ランダムで装置が故障するようにします。
シミュレーションをリセットします。
"Parametric Lathe"の"ステートメント"-"IF"をクリックします。追加した"IF~"を先頭に移動します。
[ステートメントプロパティ]ウィンドウから[コンディション]を"uniform(0,0,100) > 40"に変更します。
"Else"に、故障した時の処理を記述します。
装置の状態を、故障中である"Break"に変更します。
"Else"の下の"<Empty>"をクリックします。
"ステートメント"-"状態の設定"をクリックします。
[ステートメントプロパティ]ウィンドウから、"統計"を"Statistics"、"状態"を"Break"に変更します。
これで、ランダムで故障した際に、装置の状態を"Break"に変更するようになります。
今回は設定しませんが、故障中だった時間は統計情報で確認できます。
次に、装置の復旧作業を追加します。
"State:Break"を選択した状態で、"ステートメント"-"作業"をクリックします。
[ステートメントプロパティ]ウィンドウから"コントローラ"を"Human Transport Controller::TC"、"プロセス時間"を"30"に変更します。
これで、ランダムで装置が故障し、故障した場合は作業者が復旧作業  を行うようになります。
シミュレーションを再生します。
ランダムで装置が故障し、その間は作業者が装置前で復旧作業を行うようになりました。
以上で、「ランダムで不良品・故障が発生するようにしよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

リソースが実行するタスクの順番をミッションで制御してみよう

Gemini 1.48以降の機能です。
ラインシミュレーションの実行タスクの順番をMission Controllerで制御する方法
https://youtu.be/FRatWwU5ASU
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_118.zip

本動画では、Mission Controllerについて説明します。
Mission Controllerを使うと、実行するタスクの順番をミッションとして定義し、作業者やモバイルロボットなどのリソースをミッションの通りに動作させることができます。
この機能はバージョン1.48以降で使用できます。
Mission Controllerは、[eカタログ]ウィンドウ-"PM Navigation"にあります。配置したものがこちらです。インターフェースを使用して他のコントローラに接続すると、タスクリストが表示されます。
Mission Controllerを選択し、[コンポーネントプロパティ]ウィンドウ-"Missions"タブを選択すると、ミッションのプロパティ画面が開きます。
ミッションを作成するためのプロパティについて説明します。
"Selected Mission"では、設定対象とするミッションを選択できます。初期状態では、Mission #1というミッションが自動で作成され、設定対象になっています。
"Mission Id"では、選択中のミッションの名称を変更できます。
その下にあるボタンでは、新しいミッションを追加したり、既存のミッションを複製・削除したりすることができます。
"Enabled"では、現在選択中のミッションを有効にしたり無効にしたりできます。
[Priority]は優先度です。複数のミッションがあるときに、優先的に実行するミッションを設定できます。
"Activator"では、ミッションの開始条件を設定できます。
現在は"Scheduled"になっているため、特定の時刻にミッションが開始するようになっています。ミッションの開始時刻は[StartTime]で設定します。
また、"Recurring"にチェックを入れると、"Recurring Interval"に設定された時間間隔で、ミッションが繰り返し実行されるようになります。
また、"Limit Occurrences"にチェックを入れると、"Occurrences"に設定された回数だけミッションを実行するようになります。
"Limit Occurrences"にチェックを入れていない状態では、無限にミッションが実行されます。
ミッションの開始条件"Activator"は、Scheduledの他に、RepeatedとTriggeredがあります。
Repeatedはミッションを繰り返し実行する"Activator"で、Scheduledと同等の設定が可能です。
Triggeredは、指定したブール型シグナルに信号が送られたらミッションを実行する"Activator"です。
信号が送られた回数だけミッションが実行されます。
以上がミッションを作成するプロパティになります。
ミッション作成後は、そのミッションで実行する具体的なタスクと、その順番を定義する必要があります。
タスクの実行順はステップで管理されており、最初はStep1のタスク、次はStep2のタスク…というように、ステップの順にタスクが実行されるようになっています。
タスクを作成するプロパティについて説明します。
"Selected Step"では、設定対象とするステップを選択できます。
また、下にあるボタンからは、ステップの追加や削除、タスクの順番の入れ替えを行うことができます。
"Step Type"では、選択中のステップで実行するタスクの内容を定義します。
ここで定義できるタスクには、別のミッションを呼び出して実行する、リソースの充電を行う、指定した場所から製品を収集する、指定した場所に製品を届ける、移動する、ロボットなどのジョイントを動かす、ロボットプログラムを実行する、シグナルを送信する、待機する、特定のシグナルが送信されるまで待機する、作業をする、といったものがあります。
このWorkタスクは、プロセスモデリングでの"作業"ステートメントに相当します。
何らかの作業を実行する必要があるリソースには、ミッションでもこのタスクを定義する必要があります。
以上がタスクを作成するプロパティになります。
それでは、実際にMission Controllerを使用してみましょう。
「リソースが実行するタスクの順番をミッションで制御してみよう.vcmx」を開きます。
ここでは、まだMission Controllerを配置していません。
再生ボタンを押すと、モバイルロボットが一方通行のPathway Area上を進みながら、2 種類のコンポーネントを搬送します。搬送先では、赤色の製品に対してのみ検品作業を作業者が行っています。
モバイルロボットのタスク実行順序に着目して、もう一度見てみましょう。
シミュレーションをリセットした後に、再生ボタンを押します。1周目では、モバイルロボットはまず赤色の製品を取得し、次にベージュ色の製品を取得し、次にベージュ色の製品を降ろし、最後に赤色の製品を降ろします。
2周目も1周目と同じ順番でタスクを実行してほしいところですが、2周目ではロボットが赤色の製品を取得せずに素通りしました。
これは、1周目でベージュ色の製品が先に降ろされたことで、ベージュ色の製品の取得リクエストが先に行われたためです。
その次に行われたリクエストは赤色の製品の取得であるため、ベージュ色の製品は降ろされないまま、先に赤色の製品の取得が行われています。
このように、プロセスモデリングだけではタスクの順番が思い通りにならないことがよくありますが、Mission Controllerを使うとこの問題を解決することができます。
まず、[eカタログ]ウィンドウ-"PM Navigation"からMission Controllerを取り出します。
これをMobile Robot Transport Controllerの横に配置しておきます。
次に、[ホーム]タブ-[接続]-[インターフェース]から、Mission ControllerとMobile Robot Transport Controllerを接続します。
Mission Controllerを選択し、[コンポーネントプロパティ]ウィンドウ-"Missions"タブをクリックします。
すでにMission#1というミッションが作成された状態になっていますが、このミッションにはまだステップが定義されていません。
そのため、今再生ボタンを押してもモバイルロボットは動きません。
Mission#1のステップを設定していきます。
Step1では、最初の製品が置かれるFrom Conveyor Processまでモバイルロボットを移動させたいと思います。製品が用意される前からロボットを向かわせておき、目の前で待機させるためです。
現在、"Selected Step"は既にStep1となっているため、こちらを変更する必要はありません。
"Step Type"にはMoveを指定し、"Component"にはFrom Conveyor Processを指定します。
"Position Frame"にはResource Locationを指定し、"Align To Target"にチェックを付けておきます。
これで、Step1の設定ができました。
Step2では、From Conveyor Processから赤色の製品を収集したいと思います。
まず、"Add Step"ボタンを押して新しいステップを追加します。
Step#2が作成されました。
"Step Type"にはCollectを指定し、"Scope"にはSpecific transport nodeを指定します。
"Transport Node"にはFrom Conveyor Process :: Transport Nodeを指定し、"Component"にはFrom Conveyor Processを指定します。
これでStep2の設定ができました。
Step3では、From Conveyor Process#2からベージュ色の製品を収集したいと思います。手順はStep2のときと同様です。まず、"Add Step"ボタンを押して新しいステップを追加します。
Step#3が作成されました。
"Step Type"にはCollectを指定し、"Scope"にはSpecific transport nodeを指定します。
"Transport Node"にはFrom Conveyor Process#2 :: Transport Nodeを指定し、"Component"にはFrom Conveyor Process#2を指定します。
これでStep3の設定ができました。
Step4では、To Conveyor Processへベージュ色の製品を届けたいと思います。
まず、"Add Step"ボタンを押して新しいステップを追加します。
Step#4が作成されました。
"Step Type"にはDeliverを指定し、"Scope"にはSpecific transport nodeを指定します。
"Transport Node"にはTo Conveyor Process :: Transport Nodeを指定し、"Component"にはTo Conveyor Processを指定します。
これでStep4の設定ができました。
最後のStep5では、To Conveyor Process#2へ赤色の製品を届けたいと思います。
まず、"Add Step"ボタンを押して新しいステップを追加します。
Step#5が作成されました。
"Step Type"にはDeliverを指定し、"Scope"にはSpecific transport nodeを指定します。
"Transport Node"にはTo Conveyor Process#2 :: Transport Nodeを指定し、"Component"にはTo Conveyor Process#2を指定します。
これでStep5の設定ができました。
ここまでで、ミッションのタスクリストが完成したはずです。速度を下げて再生ボタンを押して、シミュレーションを再生してみます。
モバイルロボットはFrom Conveyorへ向かい、待機しています。
製品が運ばれてきたら、赤い製品を収集して次のFrom Conveyor#2へ向かいます。
すでにおいてあるベージュ色の製品を収集して、今度はTo Conveyorへ向かいます。
To Conveyorにベージュ色の製品を置いた後、今度はToConveyor#2へ向かい、赤色の製品を置きます。
ここまでは順調です。
しかし、ここでモバイルロボットが停止しました。
一度シミュレーションをリセットして、ミッションのプロパティ画面を確認すると、"Recurring"にチェックが付いていません。
つまり、現在のミッションは繰り返し実行される設定になっていませんでした。
ミッションが繰り返し実行されるように設定します。まずRecurringにチェックを入れます。
次に、繰り返し間隔を表す"Recurring Interval"を100秒に設定します。
これで設定は完了です。
もう一度再生ボタンを押します。赤い製品を届けた後も、モバイルロボットがタスクを続けている様子が確認できます。
また、2週目以降のタスクの順番は、1週目の時と同様、反時計回りの順でタスクをこなしていることが確認できます。
ここで、赤い製品の生成間隔を大幅に長くしてみます。
Feederを選択し、[ProductCreator]タブをクリックします。
製品の生成間隔は現在20秒に設定されていますが、これを120秒にしてみます。
シミュレーションを再生します。モバイルロボットが1つ目の赤い製品を届け終えた直後、From Conveyor Processにはまだ赤い製品が届いていませんが、モバイルロボットはFrom Conveyor Processの目の前まで移動して待機しました。
これは、ミッションのStep1に移動タスクを設定していたためです。
ここまでで、モバイルロボットの動きをミッションで制御することができました。
続いて、検品作業者の動きに着目してみます。リセットした後にもう一度シミュレーションを再生します。作業者の動きを見てみると、作業者はシミュレーション開始後、Idle Locationの上で待機してしまいます。
これを、Mission Controllerを使って作業場所の前で待機するようにしたいと思います。
まず、[eカタログ]ウィンドウ-"PM Navigation"からMission Controllerを取り出します。
これをHuman  Transport Controllerの横に配置しておきます。
次に、[ホーム]タブ-[接続]-[インターフェース]から、Mission Controller#2と「Human Transport Controller」を接続します。
これにより、作業者のコントロールをMission Controller#2が引き継ぐことになります。
Mission Controller#2のミッションにはまだタスクリストを定義していないため、シミュレーションを再生しても作業者は動きません。
ここから、タスクリストを定義していきます。
Mission Controller#2を選択し、[コンポーネントプロパティ]ウィンドウ-"Missions"タブをクリックします
Step1では、検品作業を行うプロセスの目の前に作業者を移動させます。
"Step Type"にはMoveを指定し、"Component"にはProcess Nodeを指定します。
"Position Frame"にはResource Locationを指定し、"Align To Target"にチェックを付けておきます。
これで、Step1の設定ができました。
Step2を設定する前に、一度検品作業の流れを見ておきましょう。
[プロセス]タブ-[エディタ]-[プロセス]をクリックし、QCをクリックします。
ここで検品作業を行います。まずコンベアで流れてきた製品を受け取り、10秒間作業してから、検品済の印として製品を緑色に変更します。
その後、製品をコンベアに流して完了となります。
ここで重要なのは、ミッションにはプロセス内にあるものと同様のタスクを設定する必要があるということです。
プロセス内には"作業"ステートメントがあるため、ミッションにも作業タスクを設定する必要があります。
したがって、Step2では作業タスクを設定し、作業者に検品作業を行わせるための設定をしていきます。
もう一度Mission Controller#2を選択し、[コンポーネントプロパティ]ウィンドウ-"Missions"タブをクリックします。
今はStepが1つしかないため、"Add Step"ボタンを押して新しいステップを追加します。
Step#2が作成されました。
"Step Type"にはWorkを指定します。
"Scope"にはAny process by idを指定し、"Process Group Id"にはQCを指定します。
これで、Step2が設定できました。
シミュレーションを再生します。作業者がIdle Locationには行かず、作業場所の前で待機するようになりました。赤い製品が到着すると作業者が作業を開始します。
ここまでは順調ですが、この後、作業者は作業をしなくなってしまいます。
これは、このミッションが繰り返し実行される設定になっていないためです。
"Activator"には3種類あり、1つは現在使用しているScheduledです。
この他にもRepeated、Triggeredがありますが、今回はミッションを繰り返したいので、Repeatedを選択します。
"Repeat"にチェックを入れて、ミッションが繰り返し実行されるようにします。
"Delay Between"は繰り返し間隔です。0秒の場合は、1つのミッションが完了したらすぐに次のミッションが呼び出されます。
今回はここに20秒と入力し、ミッションの繰り返し間隔を20秒にします。
今回は使用しませんでしたが、"Activator"をTriggeredに設定すると、人間に信号を送信して作業を開始させることもできます。
プロセス内、またはレイアウトのどこかにシグナルを設定し、ここに信号が送られたときにミッションを開始することができます。
今はRepeatedのままで、シミュレーションを再生します。作業者は始めに作業場所へ待機し、製品が到着したら作業を実行します。
その後、一度Idle Locationに戻り、20秒ほど経つと作業場所まで戻ってきます。
以上で、「リソースが実行するタスクの順番をミッションで制御してみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

リソースとコントローラーの設定項目について知ろう(1/4)

プロセスモデリングの、人やAGV等のリソースと、制御するコントローラの設定方法（輸送や作業の優先度、リソースへのタスクの割り当て優先度、製品の収集方法、使用する道具の指定）
https://youtu.be/cx8y_j7EzQY
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_096_p1.zip

本動画では、Transport Controllerの[既定]タブの設定と、リソースにタスクを割り当てた時の設定について説明します。
まず初めに、輸送タスクなどの優先度の設定について説明します。
「Priority確認プログラム.vcmx」を開きます。
[プロセス]タブ-[エディタ]-[フロー]をクリックします。
3Dワールド上の矢印上のひし形アイコンをクリックします。
トランスポートリンクの製品の輸送タスクと、"Work"ステートメントの作業タスクでは、それぞれ[Priority]が設定できます。
[Priority]は、タスクの優先度の設定です。
1から100の数値で設定し、値が小さいほど優先度は高くなります。
製品の輸送タスクの[Priority]は、トランスポートリンクのプロパティから設定します。
作業タスクの[Priority]は、リソースと接続しているTransport Controllerの[Work]タブから設定します。
輸送タスクと作業タスクは優先度を共有します。
値が同じ場合は、先入れ先出しの原則に沿って処理します。
シミュレーションを再生します。
どのリソースをタスクに割り当てるかは、Transport Controllerの"ResourcePriority"の設定で決まります。
"None"は、コントローラのインターフェースに接続した順番にタスクが割り当て可能かを確認し、可能なリソースから順にタスクを割り当てます。
"Nearest"は、作業位置に近いリソースにタスクを割り当てます。
"Least Utilized"は、利用状況などの統計情報をもとに、最も利用されていないリソースにタスクを割り当てます。
輸送作業などの優先度の設定についての説明は、以上になります。
次に、リソースが製品を輸送する時の収集方法について説明します。
「Strategy確認プログラム.vcmx」を開きます。
リソースは、複数の製品を同時に積み込み、輸送できます。
リソースが同時に積み込める製品の最大数は、リソースの[Transport]タブの"Capacity"で定義します。
製品を輸送する時は、まず設定した最大数分製品を積み込み、その後輸送します。トランスポートリンクが複数ある場合、トランスポートコントローラの"Strategy"の設定に則って製品を輸送します。
シミュレーションを再生します。
"Strategy"は、リソースが製品を輸送する際の、製品の収集方法などの設定です。
"One-to-One"は、1つのプロセスから製品を積み込んで、1つのプロセスへ製品を輸送する設定です。
"Strategy"を"One-to-Many"に変更して、シミュレーションを再生します。
"One-to-Many"は、1つのプロセスから製品を積み込んで、複数のプロセスへ製品を輸送する設定です。
"Strategy"を"Many-to-One"に変更して、シミュレーションを再生します。
"Many-to-One"は、複数のプロセスから製品を積み込んで、1つのプロセスへ製品を輸送する設定です。
"Strategy"を"Many-to-Many"に変更して、シミュレーションを再生します。
"Many-to-Many"は、複数のプロセスから製品を積み込んで、複数のプロセスへ製品を輸送する設定です。
リソースは、リソースの"Capacity"が一杯になるまで製品を積み込むか、輸送作業を開始するまでの間は、新しく製品を積み込むことができます。輸送作業を開始すると、その輸送作業が完了するまで新たに製品を積み込むことはできません。
リソースが製品を輸送する時の収集方法についての説明は、以上になります。
次に、リソースにツールを使用させる時の設定について説明します。
「Tool確認プログラム.vcmx」を開きます。
リソースが製品の輸送タスクや作業タスクを行う時に、ツールを設定してリソースに操作させることができます。
ツールを使用する場合、使用するツールとトランスポートコントローラをインターフェース接続する必要があります。
輸送タスク時に使用するツールの設定は、トランスポートリンクのプロパティから定義できます。
作業タスクで使用するツールの設定は、トランスポートコントローラの[Work]タブから定義できます。
各設定について説明します。
"Use Current"は、直前で使用しているツールを引き続き使用する設定です。直前でツールを使用していない場合は、ツールを使用せずタスクを行います。
"Tool Name"は、キーワードを設定して、名前にキーワードを含んだツールを3Dワールド上から検索して使用する設定です。
"ToolName"は、使用するツールを検索する時のキーワードを設定します。
ここで設定する値は、使用したいツール名と部分一致であれば問題ありません。
条件を満たすツールが複数ある場合、リソースに近いツールを使用します。
シミュレーションを再生します。
画面の場合、「Pallet Jack」と「Pallet Jack #2」があります。
"ToolName"に"Pallet Jack"と設定していますが、リソースが使用するツールは、名前に"Pallet Jack"を含み、リソースに近い「Pallet Jack #2」になります。
残りの値について説明します。
"Product Property"は、トランスポートリンクの"Tool"で使用できる設定です。
"PropertyName"には、輸送する製品に定義された文字列型の"製品プロパティ"を指定し、その値を"Tool Name"時のようにキーワードとして使用し、ツールを設定します。
"No Tool"は、ツールを使用せずタスクを行う設定です。直前にツールを使用していた場合、ツールを元の位置に戻してからタスクを行います。
画面の場合作業タスクの"Tool"を"No Tool"に設定しているためツールを元の位置に戻してから作業タスクを行っています
"ToolName"や"Product Property"を設定してツールを使用する時に、該当するツールが使用中の場合は、そのツールが使用可能になるまで待機します。
リソースにツールを使用させる時の設定についての説明は、以上になります。
次にリソースが輸送タスクの作業を行う位置とその作業位置へ移動する時の中継地点の設定について説明します。
「Approach and Resource Position確認プログラム.vcmx」を開きます。
リソースが作業を行う位置と中継地点の設定は、Transport Controllerの[LinkDefaults]タブで定義します。
シミュレーションを再生します。
"PickApproach"は、製品を積み込む作業位置へ移動する時の、中継地点の設定です。
"ResourcePickOffset"と輸送元の"ResourceLocation"を基準とします。
"PlaceApproach"は、製品を降ろす作業位置へ移動する時の、中継地点の設定です。
"ResourcePlaceOffset"と輸送先の"ResourceLocation"を基準とします。
[ResourcePickOffset]は、製品の輸送元のコンポーネントで定義されている"ResourceLocation"を基準としたオフセットで、リソースが製品を輸送元から積み込む作業を行う位置になります。
"ResourcePlaceOffset"は、製品の輸送先のコンポーネントで定義されている"ResourceLocation"を基準としたオフセットで、リソースが製品を輸送先へ降ろす作業位置になります。
Transport ControllerのLinkDefaultsタブの設定は、トランスポートリンクデフォルト値として使用されます。
個々のトランスポートリンクで設定を上書きする場合は、"UseCustomParameters"にチェックを入れます。
以上で、[既定]タブとタスク時の設定について知ろうを終わります。
ご視聴ありがとうございました。

=================================================================================

リソースとコントローラーの設定項目について知ろう(2/4)

プロセスモデリングの、人やAGV等のリソースと、制御するコントローラの設定方法（AGVの待機・充電場所、製品を持ったままの一時待機、製品の積み降ろしを補助する人やロボットの指定、積み降ろしの作業位置指定、装置がリソースを予約して占有）
https://youtu.be/5_HvtwiErIQ
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_096_p2.zip

本動画では、アイドル状態と充電の設定、WaitForNextTransportの使い方、製品の積み降ろし作業のアシストの設定、リソースをプロセスに予約状態にする方法の4つについて説明します。
まず初めに、アイドル状態と充電の設定について説明します。
「Idle Charge Location確認プログラム.vcmx」を開きます。
アイドル状態や充電の設定は、専用のコンポーネントを配置して、プロパティなどを設定する必要があります。
アイドル状態時の待機場所として使用できる"Idle Location"や、充電場所として使用できる"Charging Location"を有効にするには、各LocationのインターフェースとTransport Controllerの"Idle/ChargingLocations"インターフェースを接続する必要があります。
アイドルの設定は、リソースの[既定]タブにある"TimeToIdle"で定義します。
"TimeToIdle"で設定した秒数、アイドル状態が続いた時、リソースはTransport Controllerに接続している"Idle Location"へ移動します。
"TimeToIdle"が"0"の場合、アイドルの設定は無効になります。
"Idle Location"へ移動途中にタスクを割り当てられた場合、タスクを行うために移動します。
充電の設定は、リソースの[Power]タブで定義します。
"Enabled"が無効の場合、充電に関する設定が無効になり、シミュレーション中リソースは稼働し続けます。
"Capacity"は、リソースのバッテリー量の最大値の設定です。
"InitialCapacity"は、リソースの初期バッテリー量の設定です。
"BusyConsumption_h"は、リソースが稼働状態の時に消費される、1時間当たりのバッテリー消費量の設定です。
"IdleConsumption_h"は、リソースがアイドル状態の時に消費される、1時間当たりのバッテリー消費量の設定です。
"ReChargeRate_h"は、1時間当たりの充電量の数値の設定です。
"ToChargeLimit"は、リソースが充電場所に移動するようになるバッテリー残量の設定です。
"Capacity"を全体とした時の割合となる数字を設定します。
"ChargeUntilLimit"は、上限を設けた場合の充電できるバッテリー量です。
"Capacity"を全体とした時の割合となる数字を設定します。
"CurrentCapacity"は、リソースの現在のバッテリー残量です。
[Power]タブからは変更できません。
シミュレーションを再生します。
リソースの"CurrentCapacity"が、"Capacity"に対する"ToChargeLimit"を下回った時、トランスポートコントローラと接続している充電場所へ移動して充電を行います。
画面で接続している「Charging Location」の"Capacity"は"1"です。
複数のリソースを接続している場合、複数のリソースの"CurrentCapacity"が"Capacity"に対する"ToChargeLimit"を下回った時に、「Charging Location」が利用できないリソースが現れます。
その場合、「Charging Location」を利用できなかったリソースは、その場で停止して、充電を行います。
輸送などの作業中に"CurrentCapacity"が"Capacity"に対する"ToChargeLimit"を下回った場合は、作業が完了してから「Charging Location」へ移動します。
「Charging Location」へ移動した後、リソースの"CurrentCapacity"が"Capacity"に対する"ChargeUntilLimit"に達するまで充電を行います。
バッテリー残量が"Capacity"に対する"ChargeUntilLimit"になるまで充電した後、タスクが割り当てられている場合はタスクを行うために移動します。タスクが割り当てられていない場合は、"CurrentCapacity"が最大になるまで充電をします。
最大まで充電してもタスクが割り当てられない場合、最も近い「Idle Location」へ移動して、アイドル状態で新しいタスクが割り当てられるまで待機します。
「Idle Location」は[既定]タブの"Charger"にチェックを入れると、「Charging Location」のように充電場所としても使用できます。
また、「Charging Location」も、[既定]タブの"AllowIdling"にチェックを入れると、「Idle Location」のようにアイドル状態時の待機場所として使用できます。
アイドル状態と充電の設定についての説明は、以上になります。
次に、トランスポートリンクのWaitForNextTransportについて説明します。
「WaitForNextTransport確認プログラム.vcmx」を開きます。
[プロセス]タブ-[エディタ]-[フロー]をクリックします。
"Feeder1"、"Feeder2"、"Process #1"のプロセスラベルを右クリックして、プロセスルーチンを表示します。
「プロセスフローエディタ」ウィンドウの"フローグループ番号1"を選択した状態で、3Dワールド上の"Feeder1"-"Process #1"間のひし形アイコンをクリックします。
トランスポートリンクの"WaitForNextTransport"を有効にすることで、輸送先のプロセスが"トランスポート待機"ステートメントを実行するまで、リソースに製品を持ったまま待機させることができます。
リソースが輸送先へ到着した時に、既に"トランスポート待機"ステートメントが実行されていた場合は、製品をすぐに輸送先へ降ろします。
"トランスポート待機"ステートメントが実行されていない場合、作業位置で製品を持ったまま待機します。
シミュレーションを再生します。
画面の例では、まずVC_Canのトランスポートを開始し、その直後にBoxのトランスポートを待機します。
Boxが輸送されたら、"作業"ステートメントを実行します。
"作業"が完了するまで、リソースはVC_Canを持ったまま待機します。
"作業"が完了したら、リソースが持っているCanがプロセスへ輸送されます。
その後、2つの製品がアタッチで1つの製品となり、コンベアへ輸送されます。
トランスポートリンクのWaitForNextTransportについて説明は、以上になります。
次に、製品の積み降ろし作業のアシストについて説明します。
「LoadAssist(Human)確認プログラム.vcmx」を開きます。
[プロセス]タブ-[エディタ]-[フロー]をクリックして、3Dワールド上の"Feeder"-"Sink間のひし形アイコンをクリックします。
リソースが製品を輸送するために輸送元から製品を積み込む時、またはリソースから製品を輸送先へ降ろす時、他のリソースに製品の積み降ろし作業をさせることができます。
トランスポートリンクの[プロパティ]から"LoadAssist/UnloadAssist"を変更することで、積み降ろしの作業をさせるコンポーネントを定義します。
この時、作業をするリソースではなく、リソースを制御するコントローラを設定します。
"3Dワールドツールバー"-"フレームタイプ"をクリックして、フレームを表示します。
シミュレーションを再生します。
"Feeder"のプロセスラベルをクリックして、"TransportOut:~"をクリックします。
"LoadAssist"に設定したリソースは、トランスポートアウトステートメントの"リソースポジションフレーム"へ移動して、製品をモバイルロボットへ積みます。
"Sink"のプロセスラベルをクリックして、"TransportIn:~"をクリックします。
"UnloadAssist"に設定したリソースは、"TransportIn"の"製品ポジションフレーム"へ移動して製品を輸送先へ降ろします。
製品の積み降ろしを行うリソースは、製品を輸送するリソースが移動したら直ぐに作業位置へ移動します。
製品の積み降ろしを行うリソースが、製品を輸送するリソースより先に作業位置についた場合は、製品を持って待機するなど、先に準備をします。
製品の輸送元/輸送先のコンポーネントに"AssistLocation"という名称のフレームを定義することで、リソースが製品の積み降ろしを行う作業位置を変更することができます。
「LoadAssist(Human)_AssistLocation確認プログラム.vcmx」を開きます。
[プロセス]タブ-[エディタ]-[フロー]をクリックして、3Dワールド上の"Feeder"-"Sink"間の菱形アイコンをクリックします。
"3Dワールドツールバー"-"フレームタイプ"をクリックして、フレームを表示します。
シミュレーションを再生します。
輸送元である「Feeder Process」に"AssistLocation"フレームを定義した場合、製品を積むタスクが割り当てられたリソースは"AssistLocation"へ移動します。
その後、その位置で輸送元から製品を取り、モバイルロボットに積みます。
輸送先である「Sink Process」に"AssistLocation"フレームを定義した場合、製品を降ろすタスクが割り当てられたリソースは、まず輸送先の"TransportIn"で定義した"製品ポジションフレーム"へ移動します。
その後、その位置でモバイルロボットから製品を取ります。
その後、"AssistLocation"へ移動し、輸送先に製品を降ろします。
AssistLocationの説明は、以上になります。
製品の積み降ろしを行うリソースが、製品を輸送するリソースに取り付けられている場合、製品を輸送するリソースが作業位置へ移動して準備ができた後に、製品の積み降ろしを行います。
「LoadAssist(UR5)確認プログラム.vcmx」を開きます。
[プロセス]タブ-[エディタ]-[フロー]をクリックして、3Dワールド上の"Feeder"-"Sink"間の菱形アイコンをクリックします。
"LoadAssist"と"UnloadAssist"に「Robot Transport Controller」を指定しています。
シミュレーションを再生します。
リソースに配置されている「UR5」は、作業位置へ移動した後、製品の積み降ろし作業を行います。
製品の積み降ろし作業のアシストについての説明は、以上になります。
次に、リソースをプロセスに予約状態にする方法について説明します。
「Reserve確認プログラム.vcmx」を開きます。
[プロセス]タブ-[エディタ]-[プロセス]をクリックして、2つのManualProcessを表示します。
シミュレーションを再生します。
リソースは、"遅延"ステートメントなどによって一時的にタスクが割り当てられていない状態になった時、コントローラに他のプロセスのタスクを割り当てられます。
その場合、同一プロセスのステートメントの実行中に、他のプロセスのステートメントのタスクを実行するため、ステートメントの実行順に影響が出ることがあります。
リソースに、指定したプロセスのステートメントのタスクのみを実行させたい場合、Transport Controllerの"ReserveResource"を使用します。
"ステートメント"-"シグナル送信"をクリックして"SendSignal"ステートメントを追加し、先頭に移動させます。
"SendSignal"ステートメントをクリックして、[ステートメントプロパティ]ウィンドウから"コンポーネント"に"Human Transport Controller"を設定します。
"シグナル"を選択して、"Human Transport Controller"のシグナルを表示します。
"ReserveResource"は、トリガーした値のプロセスコンポーネントに、リソースを予約状態にするシグナルです。
シグナル送信ステートメントを使用して、値をトリガーします。
予約状態になったリソースは、"ReleaseResource"をトリガーして予約状態が解除されるか、"ReserveResource"で別のプロセスコンポーネントに予約されるまで、トリガーした値のプロセスコンポーネントのタスクのみを実行します。
予約状態のリソースと同じTransport Controllerと接続している他のリソースには、トリガーした値のプロセスコンポーネントのタスクを割り当てることができません。
"ReleaseResource"は、トリガーした値のプロセスコンポーネントに予約状態になっているリソースの、予約状態を解除するシグナルです。
この2つのシグナルは、"シグナル送信"ステートメントを使ってトリガーすることができます。
値は、プロセスコンポーネントの名前か、空文字列を設定します。
値に空文字列を設定した場合、"シグナル送信"ステートメントを実行したプロセスコンポーネントの名前を値として使用します。
ステートメントの設定を変更して、リソースを予約状態にするようにします。
"シグナル"に"ReserveResource"、"値"に空文字列を設定します。
"SendSignal:~"ステートメントをコピー&ペーストで追加し、最終行に移動させます。
最終行の"SendSignal"ステートメントの[ステートメントプロパティ]ウィンドウから"シグナル"に"ReleaseResource"を設定します。
シミュレーションを再生します。
"SendSignal"ステートメントを追加した"ManualProcess"のタスクを実行しているリソースに他のタスクが割り当たらなくなっています。
以上で、コントローラーのシグナルを使ったり、別のコンポーネントを接続してみようを終わります。
ご視聴ありがとうございました。

=================================================================================

リソースとコントローラーの設定項目について知ろう(3/4)

プロセスモデリングの、人やAGV等のリソースと、制御するコントローラの設定方法（障害物の検出・回避、移動範囲の指定、範囲内のリソースの数を制限）
https://youtu.be/7KK8-myKbos
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_096_p3.zip

本動画では、障害物を検出する方法と、移動範囲を設定する方法について説明します。
障害物を検出する方法について説明します。
コントローラーが障害物を検出する時、動的障害物と静的障害物の2種類に分類します。
動的障害物には、Avoidance機能を有効にしたTransport Controllerに接続しているリソースが該当します。
例として、"Human Transport Controller"に接続している"Human"や"Mobile Robot Transport Controller"に接続している"Mobile Robot Resource"などがあげられます。
静的障害物には、動的障害物以外のコンポーネントが該当します。例として、"Conveyor"や"Human Resource Transport Controller"に接続していない"Human"や、"Human Transport Controller"などがあげられます。
静的障害物を検出する設定について説明します。
「Obstacles確認プログラム1(静的障害物).vcmx」を開きます。
「Feeder Process」、「Sink Process」の間に「Wall」を配置して、シミュレーションを再生します。
シミュレーションを再生すると、ナビゲーションメッシュが生成されます。
ナビゲーションメッシュとは、リソースが実際に移動できる範囲のことです。
ナビゲーションメッシュは、Transport Controllerが接続しているPathwayに基づいて生成されます。
"PathwayArea"が接続されていない場合、"GlobalArea"を使用して障害物を検出して、ナビゲーションメッシュが生成されます。
"GlobalArea"の使用についての設定は、Transport Controllerの[既定]タブの"UseGlobalArea"でオン/オフを切り替えることができます。
[UseGlobalArea]のチェックを外して、シミュレーションを再生します。
Pathwayに接続がなく、かつ"UseGlobalArea"が無効の場合、障害物を検出しないため、リソースは静的障害物を無視して移動します。
Transport Controllerの、障害物検出に関係するプロパティについて説明します。
[ObstacleHorizonClearance]は、水平方向のクリアランスの設定です。
[ObstacleVerticalClearance]は、垂直方向のクリアランスの設定です。
クリアランスとは、障害物とリソースの間に設ける距離です。
"ExcludeObstacles"は、障害物として検出しないコンポーネントの設定です。
"PrecisionObstacles"は、形状などを詳細に分析するコンポーネントの設定です。
「Feeder Process」、「Sink Process」の間に「Gate」を配置して、シミュレーションを再生します。
デフォルトの設定では、障害物はコンポーネントのバウンディングボックスデータに基づいて検出されます。
ゲートのようにリソースが通過できる形状のコンポーネントを"PrecisionObstacles"に設定することで、リソースが設定したコンポーネントの内部を通過できるようになります。
"PrecisionObstacles"に"Gate"を追加して、シミュレーションを再生します。
静的障害物を検出する設定の説明は、以上になります。
次に、動的障害物を検出する設定について説明します。
「Obstacles確認プログラム2(動的障害物).vcmx」を開きます。
動的障害物は、Transport Controllerの"Avoidance"タブから"Enabled"を有効にすることで検出できるようになります。
この機能は、接続している全てのリソースに適用されます。
この機能を有効にすると、リソースが他のTransport Controllerから認識されるようになり、リソース同士が衝突しなくなります。
リソースには、障害物を検出する2つのセンサーがあります。
1つ目のセンサーは、スローセンサーといいます。範囲内に障害物が検出された時に、リソースの速度を減速させます。
この時の速度は、リソースの[既定]タブで定義されている"MoveSpeedAvoidance"で設定します。
2つ目のセンサーは、ストップセンサーといいます。範囲内に障害物が検出された時に、リソースを停止させます。
トランスポートコントローラの"Avoidance"タブのプロパティについて説明します。
"Enable"は、Avoidanceの機能を有効にします。有効になると、他のリソースから認識されるようになります。
"SlowSensorRange"は、スローセンサーの長さを定義します。リソースの原点から測定します。
"SlowSensorSideClearance"は、スローセンサーの幅を定義します。リソースのバウンディングボックスから測定します。
"StopSensorRange"は、ストップセンサーの長さを定義します。リソースの原点から測定します。
"StopSensorSideClearance"は、ストップセンサーの幅を定義します。リソースのバウンディングボックスから測定します。
"StopTimer"は、ストップセンサーで障害物を検出した時に、停止する時間を定義します。
"MaxSamplingInterval"は、センサースキャン間の最大インターバルを定義します。
この値が小さいほど、センサースキャンの頻度は高くなります。
"MaxTravelInterval"は、センサースキャン間の最大移動距離を定義します。
"MaxSamplingInterval"同様に、値が小さいほどセンサースキャンの頻度は高くなります。
"IgnoreDeadLocks"は、デッドロックを無視するかどうかを設定します。有効の場合、デッドロックが発生した時に衝突を無視してリソースは移動します。
シミュレーションを再生します。問題なく動作します。
無効の場合、デッドロックが発生した時に、リソースは停止します。
"IgnoreDeadLocks"のチェックを外して、シミュレーションを再生します。
デッドロックが発生し、リソースが停止します。
動的障害物を検出する設定の説明は、以上になります。
次に、リソースの移動範囲を設定する方法について説明します。
「PathwayArea確認プログラム1.vcmx」を開きます。
「Pathway Area」を配置することで、リソースの移動範囲や数、速度などを指定できます。リソースが"Pathway Area"上を移動するには、"Pathway Area"とリソースのトランスポートコントローラをインターフェース接続する必要があります。
「Pathway Area」同士の接続は、"PathwayArea"を近づけることで自動的に接続されます。
シミュレーションを再生します。
"DetectObstacles"を有効にすることで、"PathwayArea"上の障害物が検出できるようになります。
"OneWay"は、"Pathway Area"の進行方向を1方向に指定できます。
"LimitCapacity"は、"Pathway Area"上に配置できるリソースの数を設定できます。
「Pathway Area」は、"Pathway Capacity Group"を使うことでグループ化することができます。
「PathwayArea確認プログラム2(CapacityGroup).vcmx」を開きます。
Pathway Areaは1つのグループにしか属することができません。
グループ化すると、グループ化した全ての"Pathway Area"の"Capacity"に空きができない限り、その"Pathway Area"グループに新たにリソースを追加しなくなります。
以上で、リソースに障害物を検出させたり、移動範囲を設定しようを終わります。
ご視聴ありがとうございました。

=================================================================================

リソースとコントローラーの設定項目について知ろう(4/4)

プロセスモデリングの、人やAGV等のリソースと、制御するコントローラの設定方法（回転速度や移動速度の編集、リソースの動作停止、複数個の部品を下ろす時の順番、製品の持ち方、人の姿勢の変更）
https://youtu.be/RSAnf3pN6vo
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_096_p4.zip

本動画では、リソースで共通するプロパティについてとリソースのアニメーションについて説明します。
まず初めに、リソース共通のプロパティについて説明します。
[既定]タブのプロパティについて説明します。
"TurnSpeed"は、接続しているリソースの、その場で回転する時の回転速度を定義します。
"MoveSpeed"は、接続しているリソースの、製品を持っていない時の移動速度を定義します
"MoveSpeedLoaded"は、接続しているリソースの、製品を持っている時の移動速度を定義します。
"MoveSpeedApproach"は、接続しているリソースが作業位置へ移動する時、または作業位置から離れる時の移動速度を定義します。
"MoveSpeedAvoidance"は、他のリソースが近くにある時の移動速度を定義します。
"TimeToIdle"は、アイドル状態がどれだけ続いたら待機場所へ移動するかの時間を定義します。
"Available"は、選択しているリソースを利用可能にするかを定義します。
「Available確認プログラム.vcmx」を開きます。
「Human」をクリックした状態で、シミュレーションを再生します。
"Available"が無効の場合、リソースは動作を停止します。
シミュレーション再生中にリソースの動作を停止したい時に使用します。
"Available"を無効にすると、新たにタスクが割り当たらなくなります。
タスク中に"Available"が無効になった場合、そのタスクを完了してから動作を停止します。
シミュレーション再生中に"Available"を有効にすると、再びタスクを割り当てることができるようになります。
次に、Transportタブについて説明します。
「Transport確認プログラム.vcmx」を開きます。
[プロセス]タブ-[エディタ]-[製品]をクリックします。
Humanをクリックして、[コンポーネントプロパティ]ウィンドウ-[Transport]タブをクリックします。
このタブでは、製品を輸送する時の設定を行います。
"LIFO"は、最後に積み込まれた製品から順に製品を輸送先へ降ろす設定です。
この設定が無効の場合、最初に積み込まれた製品から順に輸送先へ製品を降ろします。
"Capacity"は、リソースが同時に持つことができる製品の最大数です。
"LIFO"と"Capacity"は輸送する製品の種類に問わず適用されます。
"Product Type"は、"TransportLocation"や"Pattern"を適用する製品をドロップダウンメニューから選択して定義します。
"Default <Any>"は、ドロップダウンメニューに追加されていない全ての製品に適用されます。
"Add New.."選択すると、製品毎に"TransportLocation"や"Pattern"を設定できます。
"ShowLocation"は、"Product Type"で選択している製品がリソースに積まれる時の、位置とパターンを表示する設定です。
"TransportLocation"は、リソースに積まれた製品の初期位置の設定です。
リソースの原点からのオフセットを定義します。
"Update From Product"は、リソースが持っている製品の位置を読み取り、選択している"Product Type"の"TransportLocation"を読み取った値に上書きする機能です。
この機能を使う場合、まずリソースに製品が積まれた状態になるまでシミュレーションを再生します。
その後シミュレーションを停止し、製品の位置を変更して、"Update From Product"をクリックします。
現在選択している"Product Type"の"TransportLocation"が変更されます。
"Default <Any>"を選択している場合、種類に関係なく最初に積まれた製品の位置を書き込みます。
"Default <Any>"以外を選択している場合、"Product Type"で選択した製品の位置を読み込んで上書きします。
"Default <Any>"以外を選択して、かつリソースに"Product Type"で選択した製品が積まれていない場合は"TransportLocation"は上書きされません。
"KeepOrientation"は、製品を輸送する時に、製品の向きを維持したまま輸送する設定です。
この機能が有効の場合、"TransportLocation"や輸送先のプロセスでの"ProductPosition"の向きの設定は無視されます。
"Pattern"は、"TransportLocation"で定義された各軸の製品の数を定義します。
"PatternStep"は、"Pattern"に沿って製品を配置する時の、製品間の距離を定義します。
"ProductType"で"Add New …"を選択すると、"ProductType"に新規の設定が追加できます。
"ProductTypeName"は、直接入力するか、製品の輸送中にシミュレーションを停止して、製品をクリックすることで設定が追加できます。
既に存在する"ProductTypeName"を入力して"Add Location"をクリックした場合、上書きはされず、代わりに、既に存在していた"ProductTypeName"を"ProductType"に設定します。
Transportタブの説明は、以上になります。
最後に、Humanのアニメーションについて説明します。
「Animation確認プログラム.vcmx」を開きます。
[プログラム]タブに移動し、「Human」をクリックします。
"Human"には、"作業"ステートメントでの作業や、製品を輸送する時の歩行などのアニメーションがロボットプログラムとしてあらかじめ定義されています。
[プログラム]タブのプログラムエディタから、修正することができます。
命名規則に従って定義すれば、オリジナルアニメーションを追加して使用することができます。
ツールを使用せずに製品を輸送する時のオリジナルアニメーションを設定する場合、プログラム名は
<製品タイプ名>_Pick、<製品タイプ名>_Place、<製品タイプ名>_Walk、<製品タイプ名>_Standになります。
例として、"Box"という製品の輸送のアニメーションを設定する場合、プログラム名をBox_Pick、Box_Place、Box_Walk、Box_Standとする必要があります。
シミュレーションを再生します。
Boxを輸送する際に、Box_で定義したプログラムが実行されます。
ツールを使用して製品を輸送する時のオリジナルアニメーションを設定する場合、プログラム名は<ツールのコンポーネント名>_Walk、<ツールのコンポーネント名>_Standになります。
<ツールのコンポーネント名>_Pickや<ツールのコンポーネント名>_Placeは、定義しても使用されません。
<ツールのコンポーネント名>の代わりに、ツール名の一部の文字列を設定することができます。
例として、Pallet Jack #1とPallet Jack #2を使用して製品を輸送するアニメーションを設定する場合、プログラム名は、Pallet_Walk、Pallet_Standなどにできます。
今回の場合、"Pallet Jack#2_Walk"、"Pallet Jack #2_Stand"を定義しています。
シミュレーションを再生します。
「Pallet Jack#2」を使って製品を輸送する時に、"Pallet Jack #2_"で定義したプログラムが実行されます。
ツールを使用せずに"作業"ステートメントのオリジナルアニメーションを設定する場合、プログラム名は<プロセス名>_Workになります。
例として、Process #1の"作業"ステートメントのアニメーションを設定する場合、プログラム名は Process #1_Workにする必要があります。
[プロセス]タブ-[エディタ]-[プロセス]をクリックし、"Process #1"をクリックします。
[プログラム]タブに戻り、「Human」をクリックします。
シミュレーションを再生します。
ツールを使用しないWorkステートメントが実行される時、"Process #1_Work"が実行されます。
ツールを使用して"作業"ステートメントのオリジナルアニメーションを設定する場合、プログラム名は<ツールのコンポーネント名>_Workになります。
<ツールのコンポーネント名>の代わりに、ツール名の一部の文字列を設定することができます。
例として、Pallet Jack #1とPallet Jack #2を使用して"作業"ステートメントのアニメーションを設定する場合、プログラム名は、Pallet＿Workなどにできます。
今回の場合、"Pallet Jack #1_Work"を定義しています。
[プロセス]タブ-[エディタ]-[プロセス]をクリックし、"Sink"をクリックします。
[プログラム]タブに戻り、「Human」をクリックします。
シミュレーションを再生します。
ツールを使用するWorkステートメントが実行される時、"Pallet Jack #1_Work"が実行されます。
以上で、リソース共通の設定や、アニメーションの設定について知ろうを終わります。
ご視聴ありがとうございました。

=================================================================================

レイアウトをCADファイルで出力してみよう

Geminiで作成したレイアウトを3DCADファイルに出力する方法
https://youtu.be/MyAYI6aaHLk

本動画では、Geminiで作成したモデルを、STEPファイルやJTファイルなどのCADファイル形式でエクスポートする方法について説明します。
まず初めに、エクスポートする用のレイアウトを配置します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Layouts]から"Turning Machine Layout"をダブルクリックします。
レイアウトを配置できました。
次に、このレイアウトをCADファイルとしてエクスポートします。
CADファイルとしてレイアウトを出力する場合は、[エクスポート]-[ジオメトリ]をクリックします。
[レイアウトをエクスポート]ウィンドウから、エクスポートするコンポーネントとファイル形式の設定ができます。
今回は、"コンポーネント"を"全て"、"ファイル形式"を".step"に設定して"エクスポート"をクリックします。
ファイルが出力されるので、CADファイルに対応しているソフトウェアでファイルを開いてください。
画面では、Gemini上で、先ほどエクスポートしたファイルを開いています。
ヘルプファイルで"CAD"を検索すると、"サポートするCADファイル"というページが見つかります。
このページで、GeminiでサポートしているCADファイルを確認することができます。
以上で、「レイアウトをCADファイルで出力しよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

ロボットの動作する速度を変更しよう

ラインシミュレーションでロボットの動作する速度を変更する方法（Robot Transport Controller）
（関連動画：ロボットを制御するコントローラについて知ろう）
https://youtu.be/vcjzJ5f29GE
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_143.zip

ロボットの動作速度を変更する方法について説明します。
付属ファイル「RobotSpeed_before.vcmx」を開きます。
シミュレーションを実行します。
コントローラーに制御されたロボットが、Feeder Processから2つのコンベアへ製品を搬送しています。
製品を搬送するロボットプログラムを確認します。
ロボットを選択し、[プログラム]タブを開きます。
[プログラムエディタ]ウィンドウには、[Main]、[home]、[vcHelperJointMove]、[vcHelperLinearMove]の4つのルーチンがあります。
製品のフローを設定することで、シミュレーション実行時、製品を搬送するロボットプログラムが、自動的に生成されます。
[vcHelperJointMove]は、各軸補間ステートメントを使用したロボットプログラムです。
各軸補間ステートメントは、スタート地点からゴール地点まで、最短時間で動作できます。
[vcHelperLinearMove]は、直線補間ステートメントを使用したロボットプログラムです。
直線補間ステートメントは、スタート地点からゴール地点まで、最短距離で動作できます。
Feeder Processからコンベアまでの動作を各軸補間ステートメント、製品を持ち上げ、下ろす動作を直線補間ステートメントが行っています。
シミュレーションをリセットします。
ラインシミュレーションの場合、ロボットコントローラーから、ロボットの動作速度を変更できます。
ロボットを制御するコントローラーについての詳細は、動画「ロボットを制御するコントローラについて知ろう」を参照してください。
ロボットコントローラーを選択し、画面右下にある[コンポーネントプロパティ]をクリックします。
[コンポーネントプロパティ]ウィンドウの[Speeds]タブが、ロボットの動作速度に関する設定です。
[Enabled]にチェックを付けることで、[Speeds]タブの設定を有効化できます。
[Enabled]にチェックを付けます。
[JointForce]は、各軸補間ステートメントの加速度、[JointSpeed]は、最大速度を変更できます。
ロボットが、各関節を回転させる時の、加速度と最大速度です。
ロボットに設定されている値に対するパーセンテージで定義できます。
デフォルトでは、50%です。
[プログラムエディタ]ウィンドウで、[vcHelperJointMove]のP1を選択します。
[Speeds]タブが無効の場合、[ステートメントプロパティ]ウィンドウの、[JointSpeed]と[JointForce]は100%です。
シミュレーションのリセットボタンをクリックします。
シミュレーションを実行します。
製品をつかむ位置から、放す位置へ移動する速度が低下したことがわかります。
シミュレーションをリセットします。
[プログラムエディタ]ウィンドウで、[vcHelperJointMove]のP1を選択します。
[ステートメントプロパティ]ウィンドウの、[JointSpeed]と[JointForce]が50%に変化しています。
ロボットコントローラーを選択します。
[コンポーネントプロパティ]ウィンドウの[AngularAcc]は、直線補間ステートメントの角加速度、[AngularSpeed]は、最大角速度を変更できます。
ロボットが、各関節を回転させる時の、加速度と最大速度です。
[CartesianAcc]は、直線補間ステートメントの最大直交座標加速度、[CartesianSpeed]は、最大直交座標速度を変更できます。
ロボットが直線移動する時の、加速度と最大速度です。
[AngularAcc]から[CartesianSpeed]の値の末尾に0を追加します。
シミュレーションのリセットボタンをクリックします。
シミュレーションを実行します。
製品をつかむ位置と、放す位置でのZ軸方向の移動速度が上昇したことがわかります。
シミュレーションをリセットします。
ロボットが製品を搬送する経路の一部のみ、動作速度を変更します。
経路の一部のみ、動作速度を変更する場合、ロボットプログラムを記録する必要があります。
[プロセス]タブを開きます。
[エディタ]グループの[フロー]を選択します。
3Dワールドに表示される矢印の内、手前の矢印を選択します。
[プロパティ]ウィンドウの[RobotMotion]で、[Record Routine]を選択することで、ロボットプログラムを記録できます。
[RoutineName]では、記録するロボットプログラムの名前を設定できます。
デフォルトのT1を使用します。
シミュレーションを実行します。
ロボットが製品を搬送完了した時点で、シミュレーションをリセットします。
[出力]ウィンドウで、製品を搬送するロボットプログラム[T1_PICK]と[T1_PLACE]を記録したことが表示されます。
記録したロボットプログラムを確認するため、[プログラム]タブを開きます。
[プログラムエディタ]ウィンドウに、[T1_PICK]と[T1_PLACE]が追加されたことがわかります。
[T1_PICK]の[Approach]を選択します。
[ステートメントプロパティ]ウィンドウの[JointSpeed]と[JointForce]を200に変更します。
ロボットの各関節に設定されている加速度と最大速度に対して、200%の加速度と最大速度で動作させます。
同様に、[T1_PLACE]の[Approach_1]を選択し、[JointSpeed]と[JointForce]を200に変更します。
[T1_PICK]の[Pick]を選択します。
[ステートメントプロパティ]ウィンドウの[MaxSpeed]を1000、[Acceleration]と[Deceleration]を2000に変更します。
同様に、[T1_PLACE]の[Place]を選択し、[MaxSpeed]を1000、[Acceleration]と[Deceleration]を2000に変更します。
記録したロボットプログラムを実行するため、[プロセス]タブを開きます。
[エディタ]グループの[フロー]を選択します。
3Dワールドに表示される矢印の内、手前の矢印を選択します。
[プロパティ]ウィンドウの[RobotMotion]で、[Execute Routine]を選択することで、記録したロボットプログラムを実行できます。
実行するロボットプログラムは、[RoutineName]で名前を指定します。
実行するロボットプログラムは「T1」です。
シミュレーションのリセットボタンをクリックします。
シミュレーションを実行します。
手前のコンベアと、奥のコンベアで、ロボットが製品を搬送する速度が異なることがわかります。
[プログラム]タブを開き、ロボットプログラムを確認します。
手前のコンベアに製品を搬送する時、[T1_PICK]と[T1_PLACE]を実行しています。
奥のコンベアに製品を搬送する時、[vcHelperJointMove]と[vcHelperLinearMove]を実行しています。
シミュレーションをリセットします。
ロボットの動作速度を変更する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットプログラムを生成してみよう

プロセスモデリングでロボットプログラムを記録し、修正し、実行する方法
https://youtu.be/G3hNtVx5XwA
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_067.zip

本動画では、プロセスモデリングで使用するロボットの動作をプログラムとして生成する方法について説明します。
まず初めに、「ロボットプログラムを生成してみよう.vcmx」を開きます。
シミュレーションを再生します。
「GenericRobot」が、輸送された製品を「Small Turning Machine」へ輸送し、加工された製品を「Conveyor #3」へ輸送します。
シミュレーション中の「GenericRobot」の動作を記録して、ロボットプログラムを生成します。
[プロセス]タブ-[エディタ]-[フロー]をクリックします。
[プロセスフローエディタ]ウィンドウの"TurningCycle2"をクリックします。
3Dワールド上の「Small Turning Machine」の"SmallTurning"-"Sink"間のひし形アイコンをクリックして、[プロパティ]ウィンドウを開きます。
[RobotMotion]は、ロボットの動作についての設定です。
"Automatic"は、ロボットに接続しているコントローラのロジックによって、ロボットを自動的に動作させます。
"Record Routine"は、"Automatic"同様にロボットを自動的に動作させます。
その時の全動作は、"RoutineName"で定義したサブプログラムに自動的に記録されます。
"RoutineName"名のサブプログラムが存在しない場合は、新規にサブプログラムを作成して記録します。
[RobotMotion]を"Record Routine"に変更します。
"RoutineName"を"NewRoutine"に変更します。
シミュレーションを再生します。
「Small Turning Machine」で加工した製品が「Conveyor #3」へ輸送されるまで再生したら、シミュレーションを停止します。
[リセット]をクリックし、[プログラム]タブをクリックします。
「GenericRobot」をクリックします。
[プログラムエディタ]ウィンドウ-"サブプログラム"に"NewRoutine"が追加されています。
"NewRoutine"をクリックします。
「GenericRobot」が、「Small Turning Machine」から「Conveyor #3」へ製品を輸送するロボットプログラムが生成されたことを確認できます。
生成したロボットプログラムは、後から修正することができます。
レイアウトにカメラのコンポーネントを追加して、「Small Turning Machine」から「Conveyor #3」へ製品を輸送する前に、そのカメラに製品を近づけて映すように"NewRoutine"を修正します。
コンポーネントを追加します。
[ホーム]タブをクリックします。
[eカタログ]ウィンドウ-[タイプ別モデル]-"Facilities - Factory"から"Quality check camera"を3Dワールド上にドラッグ&ドロップします。
「Quality check camera」をドラッグしてコンベア間のコーナーに配置します。
"NewRoutine"を修正します。
[プログラム]タブをクリックします。
[プログラムエディタ]ウィンドウ-"NewRoutine"をクリックします。
「GenericRobot」が製品を「Small Turning Machine」から「Conveyor #3」へ輸送する前に、ロボットステートメントを追加します。
"PTP Retract_1~"をクリックします。
[プログラム]タブ-[マニピュレーション]-[ジョグ]を選択した状態で「GenericRobot」の"JOG"をドラッグし、「Quality check camera」の前へ移動し、位置や向きを調整します。
位置を調整したら、[プログラムエディタ]ウィンドウから"各軸補間ステートメント"、"遅延ステートメント"と順にクリックします。
追加された"Delay~"を選択した状態で、[ステートメントプロパティ]ウィンドウから"遅延"を"10"に変更します。
これで、「GenericRobot」が製品を「Small Turning Machine」から「Conveyor #3」へ輸送する前に、製品を「Quality check camera」に近づけ、10秒間製品を映すように"NewRoutine"が修正できました。
"NewRoutine"を実行するように、"RobotMotion"を変更します。
[プロセス]タブをクリックします。
[エディタ]-[フロー]をクリックします。
[プロセスフローエディタ]ウィンドウの"TurningCycle2"をクリックします。
3Dワールド上の「Small Turning Machine 」の"SmallTurning"-"Sink"間のひし形アイコンをクリックして[プロパティ]ウィンドウを開きます。
"RobotMotion"の"Execute Routine"は、ロボットに定義されているプログラム名が"RoutineName"のサブプログラムを実行してロボットを動作させる設定です。
"RobotMotion"を"Execute Routine"に変更します。
これで、「GenericRobot」が製品を「Small Turning Machine」から「Conveyor #3」へ輸送する時に、"NewRoutine"を実行するようになりました。
シミュレーションを再生します。
「Small Turning Machine」から「Conveyor #3」へ製品を輸送する前に、製品を「Quality check camera」に近づけて映すように変更できました。
以上で、「ロボットプログラムを生成してみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

ロボットを制御するコントローラーについて知ろう(1/3)

ラインシミュレーションでロボットを制御するコントローラの使用方法（ロボットのアームの挙動、スピード、開始位置への移動）
https://youtu.be/kX72PuyFhPY
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_116_p1.zip

本動画では、ロボットを制御するRobot Transport Controllerの[既定]タブから[LinkDefaults]タブまでの機能について説明します。
まず初めに、レイアウトを作成します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Robots]-[Visual Components]から「Generic Articulated Robot」を3Dワールド上にドラッグ&ドロップします。
[タイプ別モデル]-[PM Transport Controllers]から「Robot Transport Controller」を3Dワールド上にドラッグ&ドロップします。
[マニピュレーション]-[PnP]を選択した状態で「Generic Articulated Robot」をドラッグして「Robot Transport Controller」の上に移動させ、接続します。
[タイプ別モデル]-[PM Flow Components]から"Feeder Process"と"Sink Process"を3Dワールド上にドラッグ&ドロップします。
プロセスフローを作成します。
[プロセス]タブ-[エディタ]-[フロー]をクリックします。
「Robot Transport Controller」上のひし形アイコンをクリックし、"Feeder"のプロセスラベル-"Sink"のプロセスラベルと順にクリックします。
シミュレーションを再生します。
ロボットが製品を輸送します。
これで、レイアウトを作成できました。
[既定]タブのプロパティについて説明します。
「Robot Transport Controller」をクリックし、[コンポーネントプロパティ]ウィンドウ-[既定]タブを表示します。
"Configuration"は、接続しているロボットのアームの挙動を定義します。リストの内容は、ロボットの種類によって異なります。
"Looks"は、コントローラーの外見を定義します。外見が変わるだけなので、コントローラーの機能には影響ありません。
"PedestalDiameter"は、コントローラーの幅/長さ/直径を定義します。
"Looks"同様、コントローラーの機能には影響ありません。
"PedestalHeight"は、コントローラーの高さを定義します。
コントローラーの高さが変化すると、接続しているロボットの高さも変化するため、この値の変更はロボットの可動範囲に影響します。
"VisualizeStateColor"は、接続しているロボットの現在の状態に応じて、コントローラーの色を変化させる機能です。
この機能を有効にしてシミュレーションを再生します。
コントローラーの色がロボットの作業状態の時と待機状態の時で変わります。
[既定]タブの説明は以上になります。
次に、"Speeds"タブについて説明します。
"Speeds"タブは、接続しているロボットのアームの回転速度などを定義します。
各プロパティについて説明します。
"Enabled"は、コントローラーの設定をロボットに反映するかの設定です。
"Enabled"が無効の場合、ロボットの設定に従って動作します。
"Enabled"が有効の場合、ロボットの設定をコントローラーの"Speeds"タブのプロパティで上書きします。
"JointForce"と"JointSpeed"はコントローラーのみの設定なため、ロボットの設定に上書きはされません。
"Enable"を有効にすると設定を上書きするため、再度無効にした場合でもロボットの設定は"Enabled"を有効にする前には戻りません。
"JointForce"は、「Robot Transport Controller」上部に接続されているロボットコンポーネントで定義された最大関節加速度および最大減速度に対する各軸補間動作の加速度および減速度をパーセンテージで定義します。
"JointSpeed"は、「Robot Transport Controller」上部に接続されているロボットコンポーネントで定義された最大ジョイント速度に対する各軸補間動作速度をパーセンテージで定義します。
"AngularAcc"は、直線補間動作の角加速度/減速度を定義します。
"AngularSpeed"は、直線補間動作の角速度を定義します。
"CartesianAcc"は、直線補間動作の加速度/減速度を定義します。
"CartesianSpeed"は、直線補間動作の速度を定義します。
これらの値を変更し、ロボットの設定に上書きされることを確認します。
"Enabled"以外のプロパティを任意の値で設定し、シミュレーションを再生します。
今回はJointForceから1、2、3、4、5、6と設定しています。
シミュレーションを停止します。
[プログラム]タブをクリックし、「Robot Transport Controller」をクリックします。
[プログラムエディタ]ウィンドウ-"vcHelperJointMove"をクリックし、"PTP～"を選択して、[ステートメントプロパティ]ウィンドウを表示します。
"JointSpeed"や"JointForce"の値が先ほど任意で設定した値になっていることが分かります。
[プログラムエディタ]ウィンドウ-"vcHelperLinearMove"をクリックし、"LIN～"を選択して、[ステートメントプロパティ]ウィンドウ表示します。
"MaxSpeed"、"Acceleration"、"Deceleration"、"MaxAngularSpeed"、"AngularAcceleration"、
"AngularDeceleration"の値が先ほど任意で設定した値になっていることが分かります。
これらの値が上書きされることで、シミュレーションを再生した際のロボットのアーム速度が変わります。
"Speeds"タブの説明は以上になります。
"AutoHoming"タブについて説明します。
"AutoHoming"タブは、オートホーミング機能の設定を定義するタブです。
オートホーミング機能は、接続しているロボットが何もタスクを割り当てられていないアイドリング状態が続いた時、定義したホームポジションへ自動的に移動するようにする機能です。
ホームポジションは、ロボットのサブプログラムに"home"というプログラム名で定義されます。
"Enabled"にチェックを入れて、シミュレーションを再生します。
何もタスクがないアイドリング状態が続く場合に、ロボットがシミュレーション開始時の位置に移動しているのが分かります。
シミュレーションを停止して[プログラム]タブをクリックし、「Generic Articulated Robot」をクリックします。
"home"プログラムを選択します。
オートホーミング機能が有効で、かつ"home"プログラムに何も記述されていない場合、シミュレーション開始時の位置へ移動します。
"home"プログラムに記述がある場合は、記述された位置にロボットが移動します。
[AutoHoming]タブに戻ります。
[Enabled]は、オートホーミング機能を有効にするかの設定です。
[Delay]は、ロボットがアイドリング状態になってから、ホームポジションへ移動開始するまでの待機時間を定義します。
待機時間中にロボットがアイドリング状態ではなくなった場合、ホームポジションへの移動は行われません。
[AutoHoming]タブの説明は以上になります。
[LinkDefaults]タブについて説明します。
このタブは、トランスポートリンクの[プロパティ]にある"UseCustomParameters"が無効になっている時に使用する、輸送タスク時のロボットの設定を定義します。
これ以外の値をロボットに定義したい場合は、トランスポートリンクの[プロパティ]にある"UseCustomParameters"を有効にして、トランスポートリンクで値を定義します。
各プロパティの詳細な説明は、トランスポートリンクの説明で行います。
[LinkDefaults]タブの説明は以上になります。
以上で、Robot Transport Controllerの[既定]タブから[LinkDefaults]タブまでの機能についての説明を終わります。
ご視聴ありがとうございました。

=================================================================================

ロボットを制御するコントローラーについて知ろう(2/3)

ラインシミュレーションでロボットを制御するコントローラの使用方法（作業ステートメントの動作、グリッパーの開閉、輸送ルール）
https://youtu.be/xgPksSLANPk

本動画では、ロボットを制御するRobot Transport Controllerの[Work]タブから[Transport]タブまでの機能について説明します。
「ロボットを制御するコントローラーについて知ろう～Robot Transport Controllerの[既定]タブからLinkDefaultsタブについて～」の続きであるため、先に「ロボットを制御するコントローラーについて知ろう～Robot Transport Controllerの[既定]タブからLinkDefaultsタブについて～」を視聴することを推奨します。
始めに、[Work]タブについて説明します。
このタブは、"作業"ステートメントによって作業タスクが割り当てられた時の設定を定義します。
プロパティの説明をするために、"作業"ステートメントを追加します。
[プロセス]タブ-[エディタ]-[プロセス]をクリックし、"Sink"のプロセスラベルをクリックします。
"TransportIn:~"を選択した状態で"ステートメント"の"作業"を追加します。追加された"Work:~"をクリックします。
[ステートメントプロパティ]ウィンドウから"コントローラ"を「Robot Transport Controller」に変更します。
各プロパティについて説明します。
[MotionType]は、作業タスク時に行う作業内容を定義します。
「Hold」の場合は、プロセス時間分その場で停止します。
「UpDown」の場合は、ロボットアームを上下に動かします。
「Rectangle」の場合は、四角形を描くようにロボットアームを動かします。
「CustomRoutine」の場合は、"RoutineName"で指定したロボットプログラムを実行します。
"Sequence1"を追加して、動作を確認します。
[プログラム]タブをクリックし、3Dワールド上の「Generic Articulated Robot」を選択します。
[プログラムエディタ]ウィンドウ-"シーケンスを追加"をクリックし、"Sequence1"を追加します。
[マニピュレーション]-[ジョグ]が選択されていることを確認して、「Generic Articulated Robot」の先端をドラッグして位置を変更し、"各軸補間ステートメント"をクリックします。位置を変更して、"各軸補間ステートメント"を追加します。
シミュレーションを再生すると、先ほど"Sequence1"で設定した動作をすることが分かります。
指定したプログラムがない場合は、プロセス時間分その場で停止します。
"MotionType"共通の動作内容として、ロボットアームが"作業ポジションフレーム"に移動する時間はプロセス時間に含まれます。
サーボトラック上でのロボットの移動はプロセス時間に含まれません。
"MotionDistance"は作業タスクの移動距離を定義します。
このプロパティは、"MotionType"に"UpDown"か"Rectangle"を選択した場合に設定します。
"MotionType"が"UpDown"の場合は最低地点から最高地点までの距離、"Rectangle"の場合は描く四角形の辺の長さになります。
"MotionElevation"は、作業タスクを割り当てたプロセスの"作業ポジションフレーム"のZ軸のオフセットを定義します。ロボットが実際に作業を行う位置になります。
このプロパティは、"MotionType"に"CustomRoutine"以外を選択した場合に設定します。
"作業ポジションフレーム"は、"作業"ステートメントの[ステートメントプロパティ]で設定ができます。
"MotionLoops"は、1度の作業タスク中に"MotionType"で設定した作業を何回行うかを定義します。
このプロパティは"MotionType"に"UpDown"か"Rectangle"を選択した場合に設定します。
1回の作業にかかる時間は、"作業"ステートメントで設定した"プロセス時間"に合わせて自動的にスケーリングされます。
そのため、回数が少ない場合は動作がゆっくりとなり、多い場合は動作が素早くなります。
"ScaleCycleTime"は、ルーチンプログラムの動作時間を、"作業"ステートメントで定義する"プロセス時間"内に収まるようにスケーリングする機能です。
このプロパティは、"MotionType"に"CustomRoutine"を選択した場合に設定します。
スケーリングの対象は、"各軸補間ステートメント"と"直線補間ステートメント"のみで、それ以外の動作時間は、"プロセス時間"とは別で時間がかかります。
例えば"Delay:5s"を記述している場合、プログラムの動作時間の合計は、"プロセス時間"に5秒加算されたものになります。
"Tool"は、作業タスクでロボットが使用するツールを定義します。
"Use Current"の場合は、直前で使用していたツールを引き続き使用します。
ツールを使用していなかった場合は、そのままツールを使用せず作業タスクを行います。
"Tool Name"の場合は、使用するツールを検索する時のキーワードを設定して、使用するツールを決めます。
設定する値は、4文字以上の文字列である必要があります。
ここで設定した文字列は、使用したいツールの名称と部分一致であれば問題ありません。
"ToolName"に入力したキーワードを名前に含んだツールを3Dワールド上から検索して使用します。
条件を満たすツールが複数ある場合は、コントローラーに一番近いものを使用します。
設定した名称のツールが存在しない、もしくは届かない位置にある場合はエラーが出力され、ロボットは動かなくなります。
直前のタスクでツールを使用しており、"作業"タスクで別のツールを使用する場合は、直前に使用していたツールを元の位置に戻してから、"作業"タスクを行います。
直前のタスクでツールを使用しており、"作業"タスクで同じツールを使用する場合は、そのまま"作業"タスクを行います。
ツールを追加して、動作を確認します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Robot Tools]-[Visual Components]から"Generic 3 -Jaw Gripper"を3Dワールド上にドラッグ&ドロップします。
「Generic 3 -Jaw Gripper」を選択した状態で[コンポーネントプロパティ]ウィンドウ-[既定]タブから名前を「Gripper2」に変更します。
「Robot Transport Controller」をクリックし、[コンポーネントプロパティ]ウィンドウ-[Work]タブから、"Tool"が"Tool Name"、"ToolName"が"Gripper2"であることを確認して、シミュレーションを再生します。
作業タスクを実行中にツールを使用するようになりました。
"No Tool"の場合は、ツールを使用せず作業タスクを行います。
直前のタスクでツールを使用していた場合は、使用していたツールを元の位置に戻してから、作業タスクを行います。
"Priority"は、作業タスクの優先度を定義します。1~100の数値を設定し、値が小さいほど優先度が高くなります。
優先度が同じ場合、先入れ先出しの原則に基づいて処理されます。
[Priority]は、輸送タスクにも同名のプロパティがあります。
作業タスクの[Priority]と輸送タスクの[Priority]は設定が共有されます。
画面では、2つのプログラムのシミュレーション再生の様子を映しています。
両画面どちらも、2つのトランスポートリンクと1つの"作業"ステートメントを実装しています。
左側は、全ての[Priority]を"1"に設定しており、順番にタスクを行っています。
右側は、"Feeder1-Sink1"のトランスポートリンクの[Priority]を"1"、"Feeder2-Sink2"のトランスポートリンクの[Priority]を"2"、Robot Transport Controller の"Work"の[Priority]を"3"に設定しています。
そのため、"Feeder1-Sink1"間の輸送タスクが最優先で行われ、作業タスクは他のタスクがない時にのみ行っています。
[Work]タブの説明は以上になります。
次に、"Advanced"タブについて説明します。
"UseGripperSignals"を有効にすると、接続しているグリッパーのシグナルを通して、グリッパーの開閉を制御します。
"GraspSignalPortIndex"は、ロボットがコントローラーと接続した時に、コントローラーの"GraspSignal"信号に自動的に接続されるロボットの出力信号のポート番号を定義します。
"GraspContainerName"は、アームが製品をピックする時に使用するロボットコンポーネント内のコンテナビヘイビアの名前を定義します。
コンテナビヘイビアの名前は、[モデリング]タブ-[コンポーネントグラフ]ウィンドウ-"ビヘイビア"の左側にあるプラスアイコンをクリックし、表示される名前を指定します。
"ToolInterfaceName"は、ロボットアームの先端にツールを接続するための、ロボットコンポーネント内のインターフェースビヘイビアの名前です。
この2つは、空欄にした場合や指定した名称のビヘイビアが見つからなかった場合は、デフォルト値が入ります。特に設定をしない場合は、空欄のままで問題ありません。
インターフェースビヘイビアの名前は、[モデリング]タブ-[コンポーネントグラフ]ウィンドウ-"Link1"の左側にあるプラスアイコンをクリックし、表示される名前を指定します。
"Advanced"タブの説明は以上になります。
次に[Transport]タブについて説明します。
[Transport]タブは、ロボットに輸送タスクが割り当てられた時の設定を定義します。
"Capacity"は、接続しているロボットが輸送時に同時に持つことができる製品の数を設定します。
初期値として"1"が設定されており、ダブルグリッパーなどを使用する時は"2"に変更する必要があります。
"MultiPickStrategy"は、輸送タスクを行う時に製品の搬入元、搬出先が複数ある場合のルールを定義します。
"One-to-One"の場合は、1つのプロセスから製品を搬入し、1つのプロセスへ搬出します。
"One-to-Many"の場合は、1つのプロセスから製品を搬入し、複数のプロセスへ搬出します。
"Many-to-One"の場合は、複数のプロセスから製品を搬入し、1つのプロセスへ搬出します。
"Many-to-Many"の場合は、複数のプロセスから製品を搬入し、複数のプロセスへ搬出します。
輸送する製品は、先入れ先出しの原則に基づいて、ロボットに搬入された順に搬出します。
[Transport]タブの説明は以上になります。
以上で、Robot Transport Controllerの[Work]タブから[Transport]タブまでの機能についての説明を終わります。
ご視聴ありがとうございました。

=================================================================================

ロボットを制御するコントローラーについて知ろう(3/3)

ラインシミュレーションでロボットを制御するコントローラの使用方法（輸送の自動ティーチング、指定ルーチン実行、ツール設定、ピック/プレースの時間と方向）
https://youtu.be/ES74BbXz3jI

本動画では、ロボットを制御するトランスポートリンクのプロパティについて説明します。
「ロボットを制御するコントローラーについて知ろう～Robot Transport ControllerのWorkタブからTransportタブについて～」の続きであるため、先に「ロボットを制御するコントローラーについて知ろう～Robot Transport ControllerのWorkタブからTransportタブについて～」を視聴することを推奨します。
輸送タスクの設定は、[Transport]タブや[LinkDefaults]タブ以外にも、トランスポートリンクの[プロパティ]で定義できます。
トランスポートリンクの[プロパティ]で、輸送タスクの設定を変更します。
[プロセス]タブ-[エディタ]-[フロー]をクリックしてプロセスフローエディタを開きます。
"Feeder-Sink"間のひし形アイコンをクリックして、[プロパティ]ウィンドウを表示します。
各プロパティについて説明します。
"Priority"は、輸送タスクの優先度を1~100の数値で定義します。仕様は、[Work]タブで設定したものと同じです。
[RobotMotion]は、輸送タスク時のロボットの動作を定義します。選択肢は"Automatic"、"RecordRoutine"、"ExecuteRoutine"の3つです。
"Automatic"の場合は、コントローラーの内部ロジックでロボットを制御して、輸送タスクを行います。
"RecordRoutine"の場合は、"Automatic"と同様に内部ロジックでロボットを制御して、輸送タスクを行います。
"Automatic"との違いは、輸送タスク中のロボットの動作がロボットルーチンとしてサブプログラムに記録されることです。
記録されたロボットルーチンは、[プログラム]タブで編集などを行うことができます。
[プログラム]タブをクリックして、3Dワールド上の「Generic Articulated Robot」を選択し、[プログラムエディタ]ウィンドウを表示します。
"サブプログラム"の"T1_PICK"と"T1_PLACE"は、先ほどのシミュレーション再生によって記録されたプログラムです。
"ExecuteRoutine"の場合は、"RoutineName"で指定した名称のロボットルーチンを実行します。
実行するロボットルーチンには、製品をつかむステートメントである"出力値"が"True"の"バイナリ入力待機ステートメント"と、製品を離すステートメントである"出力値"が"False"の"バイナリ入力待機ステートメント"が記述されている必要があります。
また、この時使用するシグナルには、"Advanced"タブの"GraspSignalPortIndex"の値を設定する必要があります。
"RecordRoutine"と"ExecuteRoutine"では、それぞれ"RoutineName"と"Base"を設定します。
"RoutineName"は、保存もしくは実行するロボットルーチンの名称を定義します。
今回、"RoutineName"に定義しているのは「T1」であるため、"サブプログラム"の"T1_PICK"と"T1_PLACE"が対象のプログラムです。
"Base"は、"RecordRoutine"でロボットルーチンを記録する時の、ロボットが使用するベースフレームを定義します。
ベースフレームとは、ロボットなどのコンポーネントが3Dワールド内の場所を簡易化するために使用する座標系のことです。
"Attach to Target"の場合、ベースフレームをFeeder Process やSink Process などの製品をピック/プレースする対象の位置に関連付けます。
そのため、ロボットルーチンを記録した後にロボットの位置を変更しても、ベースフレームの位置は変わりません。
これにより、ロボットルーチンを記録した後でも、レイアウトの編集ができます。
"Robot World"の場合、ベースフレームをロボットの位置に関連付けます。
そのため、ロボットルーチンを記録した後にロボットの位置を変更すると、それに追従してベースフレームも移動します。
[RobotMotion]を"Automatic"に戻します。
"UseCustomParameters"は、各プロパティを編集可能にするかの設定です。
有効にすると、ロボットの動作に関する各プロパティを設定できるようになります。
コントローラーの[LinkDefaults]タブで設定した値を、初期値として使用します。
"UseCustomParameters"を有効にして値を設定した後に"UseCustomParameters"を無効にし、再度有効にした場合は、[LinkDefaults]タブの値に上書きされます。
"Tool"は、製品の輸送タスクを行う際に使用するツールを定義します。
"Use Current"、"Tool Name"、"No Tool"については、[Work]タブのものと同じです。
"Product Property"の場合は、製品が持つ"製品プロパティ"の値によって使用するツールを決めます。
"PropertyName"には、輸送する製品が持つ"製品プロパティ名"を設定します。
あらかじめ、製品タイプエディタから製品に製品プロパティの追加と設定を行う必要があります。
実際に設定して動作を確認します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Products and Containers]から"Box"と"Cube"を3Dワールド上にドラッグ＆ドロップします。
[タイプ別モデル]-[Robot Tools]-[Visual Components]から「Generic 3 -Jaw Gripper」を3Dワールド上にドラッグ&ドロップし、[名前]を「Tool1」に変更します。
同様に"Parametric Box Gripper"を3Dワールド上にドラッグ&ドロップし、[名前]を"Tool2"に変更します。
[プロセス]タブ-[エディタ]-[製品]をクリックして、[製品タイプエディタ]ウィンドウを開き、"フローグループ番号1"を選択した状態で、"製品の定義"-"製品タイプを追加"を2回クリックします。
"製品タイプ番号1"を選択し、[Name]を"Box"に変更、"Pick Component from 3D world"をクリックして3Dワールド上の「Box」を選択します。
[製品タイプエディタ]ウィンドウ-"Box"横のプラスアイコンをクリックして展開し、"製品プロパティ"を右クリックして"製品プロパティを追加"をクリックします。
追加された製品プロパティの[名前]を"ToolName"、"Type"を"String"、"Default Value"を"Tool1"に設定します。
"製品タイプ番号2"を選択し同様に設定を行います。
[Name]を"Cube"に変更、"Pick Component from 3D world"をクリックして3Dワールド上の「Cube」を選択します。
[製品タイプエディタ]ウィンドウ-"Cube"横のプラスアイコンをクリックして展開し、"製品プロパティ"を右クリックして"製品プロパティを追加"をクリックします。
追加された製品プロパティの[名前]を"ToolName"、"Type"を"String"、"Default Value"を"Tool2"に設定します。
3Dワールド上の「Feeder Process」をクリックします。
[コンポーネントプロパティ]ウィンドウ-[ProductCreator]タブをクリックします。
"フィードモード"を"分布"、"制限"を"100"に設定し、"パーツを選択"から"Box"と"Cube"を選択します。
"Feeder-Sink"間のひし形アイコンをクリックします。
"Tool"を"Product Property"に変更します。
[PropertyName]を「ToolName」に設定します。
[プログラム]タブ-[リミット]-[リミットで停止]にチェックが付いている場合、シミュレーションが停止してしまうため、チェックが付いていないことを確認してください。
シミュレーションを再生します。輸送タスクを行う時に、製品ごとに設定した"ToolName"に合致するツールを使用するようになりました。
"PropertyName"で設定した文字列と合致する製品プロパティが存在しない場合はエラーが出力されます。
"Feeder-Sink"間のトランスポートリンクのプロパティに戻ります。
"PickTime"と"PlaceTime"は、それぞれ製品をピック/プレースするのにかかる時間です。
"PickApproach"と"PlaceApproach"は、それぞれ製品をピック/プレースする位置です。初期設定は"0/0/100"となっています。
「Feeder Process」の中心を0/0/0として、生成される製品の高さだけ、Zのオフセットを設定しています。
設定を変更して、シミュレーションを再生します。画面では、"PickApproach"と"PlaceApproach"をそれぞれ"50/150/300"に変更しました。
製品をピックするときとプレースする時で、動きが変化しました。
設定を元に戻します。
コンポーネントに"pick"というフレームが含まれている場合は、"PickApproach"の値にかかわらず、"pick"フレームから製品をピックします。
実際に、Cubeにpickフレームを追加して動作を確認します。
[モデリング]タブに移動します。
"Cube"を選択し、"フィーチャ"からフレームを追加します。名前を"pick"に変更します。
スナップなどで、位置や向きを調整します。
次に、製品タイプを更新します。
[プロセス]タブ-[製品]をクリックします。
"Cube"をクリックし、"コンポーネントURI"を空欄にして、Enterキーを押下します。
その後、"Pick Component from 3D world"をクリックし、「Cube」をクリックします。
これで、設定ができました。
シミュレーションを再生します。
Cubeをピックするとき、pickフレームからピックするようになりました。
プロパティの説明に戻ります。
"PickApproachFrameFilter"と"PlaceApproachFrameFilter"は、プロセスコンポーネント内のフレームのうち、指定した文字列で終わるフレームをフィルタリングする機能です。
各動作位置に移動する際に、フィルタリングされたフレームを通過するようになります。初期設定の場合、名称に"Approach"という文字列を含むフレームがないため、動作に影響はありません。
設定を変更して、動作を確認します。
"PickApproachFrameFilter"を"Frame"に変更します。
[モデリング]タブをクリックします。
「Feeder Process」の"InterfaceFrame"の位置を上に移動させます。
"InterfaceFrame"を2回コピー&ペーストして、"InterfaceFrame_1"と"InterfaceFrame_2"を生成し、それぞれのフレームの位置を変更します。
シミュレーションを再生します。
製品をピックする前に"InterfaceFrame"-"InterfaceFrame _1"-"InterfaceFrame _2"の順にフレームを通過しているのが確認できます。
また、製品をピックした後に輸送する時は逆順にフレームを通過しています。
"PickApproachDirection"と"PlaceApproachDirection"は製品をピック/プレースする時に、どの方向からロボットアームを近づけるか定義します。
設定を変更して、シミュレーションを再生します。
画面では、[PickApproachDirection]と[PlaceApproachDirection]を「-Z」に変更しました。
製品をピック/プレースする時に近づける方向が変わりました。
この設定は、pickフレームが定義されている製品には適用されません。
次のプロパティから違うレイアウトで説明します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Layout Templates]-"Dual Gripper Machine Tending"を3Dワールド上にドラッグ＆ドロップします。
[プロセス]タブ-[エディタ]-[フロー]をクリックしてプロセスフローエディタを開きます。
"Feeder-Process1"間のひし形アイコンをクリックして、[プロパティ]ウィンドウを表示します。
"SwapAtSource"から"SwapTcpAt"の4つのプロパティは、ロボットアームのツールにダブルグリッパーが接続している時に使用します。
"SwapAtSource"は、リンク元のプロセスから製品をピックし、その直後に同じグリッパーにある、違うツールフレームを使用して、同じプロセス内で別の製品をプレースしたい場合に有効にします。
"SwapAtDestination"は、リンク先のプロセスに製品をピックして、その直後に同じプロセス内で同じグリッパーの違うツールフレームを使って別の製品をプレースしたい場合に有効にします。
現在のレイアウトでシミュレーションを再生すると、"Feeder-Process1"間の"SwapAtSource"が無効、"SwapAtDestination"が有効であるため、"Feeder"は製品をピックするのみ、"Process1"は製品をピックした後、違うツールフレームを使用して製品をプレースします。
"Process1-Process2"間は"SwapAtSource"が有効、"SwapAtDestination"が有効であるため、"Process1"、"Process2"はどちらも製品をピックした後、違うツールフレームを使用して製品をプレースします。
"Process2-Sink"間は"SwapAtSource"が有効、"SwapAtDestination"が無効であるため、"Process2"は製品をピックした後、違うツールフレームを使用して製品をプレースし、"Sink"は製品をプレースするだけの動作となります。
"PreApproachTo"は、ロボットがスワップをする際の待機場所を定義します。
"Feeder-Process1"間の"PreApproachTo"を"First Approach Target"に設定して、シミュレーションを再生すると、"Process1"の最初の位置で停止します。
"Feeder-Process1"間の"PreApproachTo"を"Last Approach Target"に設定して、シミュレーションを再生すると、"Process1"の最後の位置で停止します。
"SwapTcpAt"は、ロボットが使用するツールフレームを切り替える位置を定義します。
"Feeder-Process1"間の"SwapTcpAt"を"First Approach Target"に設定して、シミュレーションを再生すると、"Process1"の最初の位置でツールフレームを切り替えます。
"Feeder-Process1"間の"SwapTcpAt"を"Last Approach Target"に設定して、シミュレーションを再生すると、"Process1"の最後の位置でツールフレームを切り替えます。
プロジェクトを本動画の初期状態にします。
"PickPositionOffset"から"RobotJointsOnMove"までのプロパティは、ロボットがサーボトラックに接続している時の設定です。
ロボットとサーボトラックを接続して、動作を確認します。
[eカタログ]ウィンドウ-[タイプ別モデル]-"Robot Positioners"から"Generic Servo Track"を3Dワールド上にドラッグ&ドロップします。
[マニピュレーション]-[PnP]を選択した状態で「Generic Articulated Robot」をドラッグして、「Robot Transport Controller」から距離を離し、接続を解除します。
「Robot Transport Controller」をドラッグして、「Generic Servo Track」の台座付近へ近づけ、接続します。
「Generic Articulated Robot」をドラッグして、「Generic Servo Track」の台座付近へ近づけ、接続します。
シミュレーションを再生します。
サーボトラックの台座がスライドし、ロボットが製品を輸送します。
"PickPositionOffset"と"PlacePositionOffset"は、製品をピック/プレースするコンポーネントの位置を基準としたオフセットで、ロボットが実際に製品のピック/プレースをする位置です。
"Position Tolerance"は、製品をピック/プレースをする場所を基準とした範囲を定義します。
この範囲内にすでにロボットがいる場合、ロボットのサーボトラック上での動きはフィルタリングされます。
"JointSpeed"は、ロボットがサーボトラック上を移動する時の速度を定義します。
速度は、サーボトラックが設定した最高速度に対する、プロパティで設定したパーセンテージに設定されます。
"RobotJointsOnMove"は、ロボットがサーボトラック上を移動する時のロボットの姿勢を定義します。各関節の角度を、カンマ記号で区切って設定します。
"Implementer"は、このプロセスフローの輸送タスクを、どのコントローラに割り当てるか定義します。
以上で、トランスポートリンクのプロパティについての説明を終わります。
ご視聴ありがとうございました。

=================================================================================

作業者に製品を輸送させよう

指定した場所の間で、作業者に製品を輸送させる方法
https://youtu.be/jnqodkf6CsA
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_046.zip

本動画では、作業者に製品を輸送させる方法について説明します。
まず初めに、「作業者に製品を輸送させよう.vcmx」を開きます。
このレイアウトを編集して、「Human」が製品をコンベアから棚へ、棚からコンベアへ輸送するようにします。
「Human」などの作業者に製品を輸送させるには、まずプロセスフローを作成します。
プロセスとは、コンポーネントに実装されている、シミュレーション中に行う動作内容を記述したものです。
プロセスフローとは、製品の出発点のプロセスと到達点のプロセスを接続することで、製品を輸送する流れを指定するものです。
プロセスフローを作成して、プロセス間の製品の輸送を「Human」に割り当てることで、「Human」が製品を輸送するようになります。
プロセスフローの作成方法について説明します。
[プロセス]タブ-[エディタ]-[フロー]をクリックします。
接続元になるプロセスノード、またはプロセスラベルをクリックすると、プロセスノードが黄色に変化します。
この状態で、接続先となる別のプロセスのプロセスノード、またはプロセスラベルをクリックすると、接続元のプロセスと接続先のプロセスが緑色の矢印で接続され、プロセスフローが作成されます。
プロセスフローを作成する時にプロセスラベルをクリックすると、3Dワールド上にある同名のプロセス全てが選択されます。
そのため、一度に多くのプロセスを接続元、または接続先にして、プロセスフローが作成できます。
生成された緑色の矢印はトランスポートリンクといい、矢印方向にプロセス同士が接続していることを表示しています。
この状態でシミュレーションを再生しても、製品は輸送されません。
作成したプロセスフローをシミュレーションに反映させるには、[プロセスフローエディタ]ウィンドウの"フローステップ"内にプロセスを追加する必要があります。
追加する方法は、1."フローステップ"内を右クリックし"こちらに追加"をクリックして追加したいプロセスを選択する方法、2.右の十字アイコンをクリックして追加したいプロセスを選択する方法、3.3Dワールド上の追加したいプロセスにカーソルを合わせ、プロセスラベルをクリックする方法、4.プロセスラベルをフローステップへドラッグ&ドロップする方法 の4種類あります。
プロセスフローを作成する時に、プロセスノードをクリックした場合は"フローステップ"にプロセスは追加されないため、いずれかの方法で"フローステップ"にプロセスを追加してください。
"フローステップ"に"FromConveyor"を追加します。
"フローステップ"に追加したプロセスは、プロセスフローを作成した時の接続順に合うように並び替えてください。
プロセスをドラッグすることで、"フローステップ"内の場所を移動できます。
シミュレーションを再生します。製品が輸送されるようになりました。
"フローステップ"のひし形アイコンをクリックしてDeleteキーを押下します。
トランスポートリンクが削除され、"フローステップ"内の、ひし形アイコンが赤色に変化しました。
これはプロセス間の接続がなく、プロセスフローが作成されていない状態であることを表示しています。3Dワールド上で選択しているプロセスノードをクリックして、選択状態を解除します。
プロセスの接続の仕方には、4種類あります。
1つめは、One-to-One 接続です。1つのプロセスから1つのプロセスへ接続します。
いずれかの"FromConveyor"のプロセスノード-"Buffer"のプロセスノードと順にクリックします。
シミュレーションを再生すると、選択したプロセスのコンベアから選択した棚へ製品が輸送されます。
2つめは、One-to-Many 接続です。1つのプロセスから複数のプロセスへ接続します。
先ほど作成したプロセスフローを削除します。
3Dワールド上でプロセスを選択している場合は、プロセスノードをクリックして選択を解除します。
"フローステップ"の"FromConveyor"を選択します。
3Dワールド上のいずれかの"FromConveyor"のプロセスノード-"Buffer"のプロセスラベルと順にクリックします。
選択した"FromConveyor"と6つの"Buffer"を接続したプロセスフローが作成できました。
プロセスラベルをクリックした時、"フローステップ"に同名のプロセスが存在していても、プロセスが追加されます。
"フローステップ"の最後の"Buffer"を削除します。
シミュレーションを再生すると、1つのコンベアから6つの棚へ製品が輸送されます。
3つめは、Many-to-One 接続です。複数のプロセスから1つのプロセスへ接続します。
先ほど作成したプロセスフローを削除します。
同じ構成のプロセスフローを一度に削除する場合は、まず"プロセスステップ"内のひし形アイコンをクリックします。
同じ構成のプロセスフローが複数選択されるため、そのままDeleteキーを押下すると一度に削除できます。3Dワールド上でプロセスを選択している場合は選択を解除します。
"フローステップ"の"FromConveyor"を選択します。
3Dワールド上のいずれかの"FromConveyor"のプロセスラベル-"Buffer"のプロセスノードと順にクリックします。
これで4つの"FromConveyor"から選択した"Buffer"へ製品を輸送するプロセスフローが作成できました。
シミュレーションを再生すると、4つのコンベアから1つの棚へ製品が輸送されます。
4つめは、Many-to-Many 接続です。
複数のプロセスから複数のプロセスへ接続します。
先ほど作成したプロセスフローを削除します。
3Dワールド上でプロセスを選択している場合は選択を解除します。
"フローステップ"の"FromConveyor"を選択した状態で、3Dワールド上のいずれかの"FromConveyor"のプロセスラベル-"Buffer"のプロセスラベルと順にクリックします。
これで4つの"FromConveyor"から6つの"Buffer"へ製品を輸送するプロセスフローが作成できました。
"フローステップ"の最後の"Buffer"を削除します。
シミュレーションを再生すると、4つのコンベアから6つの棚へ製品が輸送されます。
プロセスフローは、これら4つの接続方法を組み合わせて作成します。
次に、プロセス間の輸送方法の設定について説明します。
プロセスフローを生成すると、プロセス間にひし形アイコンが表示されます。
このひし形アイコンは、プロセス間の製品の輸送方法を定義しており、右クリックすることで輸送方法を変更できます。
このとき、トランスポートコントローラを選択した状態にしていると、そのトランスポートコントローラに接続している作業者にプロセスフロー間の製品の輸送を割り当てることができます。
また、プロセスフロー作成時にトランスポートコントローラを選択状態にしていると、プロセス間の製品の輸送をトランスポートコントローラに割り当てた状態でプロセスフローが作成されます。
トランスポートコントローラを変更することによって、輸送する手段を作業者からAGVなどに変更することができます。
一度プロセスフローを削除します。
ここまでの説明を踏まえて、"FromConveyor"プロセスから"Sink"プロセスまでのプロセスフローを作成します。
「Human Transport Controller」を選択状態にして、"FromConveyor"のプロセスラベル、"Buffer"のプロセスラベル、"ToConveyor"のプロセスラベルと、順にクリックします。
次に、「Human Transport Controller」の選択状態を解除して、"Sink"のプロセスラベルをクリックします。
これで、"FromConveyor-Buffer-ToConveyor"までの輸送を「Human Transport Controller」に接続された「Human」が、"ToConveyor-Sink"までの輸送をコンベアが行うプロセスフローが作成できました。
シミュレーションを再生すると、"Box"の輸送が行われます。
また、「Human Transport Controller」を選択し、[コンポーネントプロパティ]ウィンドウ-[既定]タブの"Show Traffic"をクリックすると、「Human Transport Controller」に接続されている「Human」の軌跡が表示されます。
最後に、トランスポートリンクの削除について説明します。
[エディタ]-[フロー]をクリックします。
トランスポートリンクの削除は、3Dワールド上のひし形アイコンを右クリックして"削除"を押下、または3Dワールド上かプロセスフローエディタ上のひし形アイコンを選択した状態でDeleteキーを押下することで削除することができます。
プロセスフローエディタからプロセスを削除すると、そのプロセスのトランスポートリンクは非表示になります。
この時、プロセスフローは削除されていないため、プロセスフローエディタに再度プロセスを追加するとトランスポートリンクは表示されます。
プロセスフローの再設定等で"フローステップ"のプロセスとトランスポートリンクを削除する必要がある場合は、トランスポートリンクを削除してから、プロセスステップ内のプロセスを削除してください。
以上で、「作業者に製品を輸送させよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

作業者の移動量・移動時間を確認しよう

作業者の移動量・移動時間を統計ダッシュボードに表示して確認する方法。
https://youtu.be/G2-89dy_bFw
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_153.zip

本動画では、シミュレーション中の作業者の移動量・移動時間を確認する方法について説明します。
作業者などのコンポーネントにはプロパティが定義されており、そのプロパティの変動を統計ダッシュボードに表示して確認します。
初めに、「作業者の移動量・移動時間を確認しよう.vcmx」を開きます。
シミュレーションを再生します。作業者は製品を運んだり、作業台で作業を行います。何もタスクが割り当てられていない場合、「Idle Location」へ移動して待機します。
このレイアウトに、作業者の移動量と移動時間を確認できるよう設定します。
シミュレーションをリセットします。
[ホーム]タブ-[統計情報]をクリックします。
統計ダッシュボードが表示されます。
統計ダッシュボードは、シミュレーション中のプロパティ値をグラフに出力する機能です。
"レイアウト"は、ダッシュボードのグラフの配置の設定です。
今回は、"2列1行標準ダッシュボード"を選択し、"クリエイト"をクリックします。
ダッシュボードのチャートには、"シンプルチャート"と"テンプレートチャート"の2種類あります。
"シンプルチャート"は、使用するグラフの種類や表示するプロパティなどの設定を、全て自分で設定してグラフを作成します。
"テンプレートチャート"は、使用するグラフの種類や表示するプロパティが全て設定された状態で、グラフを作成します。
このチャートを使用する場合は、あらかじめ表示するプロパティが設定済みのコンポーネントを選択する必要があります。
確認したい情報のグラフがテンプレートチャートに登録されている場合、そのテンプレートチャートを使うことで、スムーズにグラフを作成できます。
今回の場合、作業者の移動量のグラフは、テンプレートチャートの"移動距離"を使って作成します。作業者の移動時間のグラフはテンプレートチャートにないので、シンプルチャートを使って作成します。
どちらのチャートを使用する場合でも、後からグラフの種類や表示するプロパティを変更できます。
今回は、左側にテンプレートチャートを使って移動量を表示し、右側にシンプルチャートを使って移動時間を表示します。
移動量の表示から設定します。
3Dワールド上の「Human (Anna)」をクリックします。左ウィンドウの"テンプレートチャート"の"移動距離"をクリックします。
このテンプレートチャートは、選択したコンポーネントの"TravelDistance"を"ラインチャート"で表示します。
これで、作業者の移動量が表示されるようになりました。
次に、移動時間を表示する設定をします。
右ウィンドウのシンプルチャートのラインチャートをクリックします。
[プロパティ]ウィンドウから、ダッシュボードに移動時間を表示するように、設定を変更します。
グラフ2の"名称"を"Human (Anna):移動時間"に変更し、"説明文の可視性"と"タイトルの可視性"にチェックを入れます。
"データ系列"の"名称"を"Human (Anna)"、"コンポーネント"を"「Human (Anna)」に設定します。
表示するプロパティを設定します。
移動時間を計測するプロパティはないため、代わりに「シミュレーション全体の時間に対する、作業者が移動中だった割合」を計測する"Statistics.StateMovingParcentage"を使用します。
統計ダッシュボードの詳細は、別動画「シミュレーション中に統計情報を取得して表示させよう」を参照ください。
これで、ダッシュボードの左側に移動量、右側に移動時間が表示されるようになりました。
シミュレーションを再生します。
統計ダッシュボードに作業者の移動量、移動時間が表示され、更新されることが確認できます。
シミュレーションをリセットします。
ダッシュボードを更新するまでの間隔は、[統計情報]-[間隔]で設定します。初期設定は"60s"です。
[統計情報]の[間隔]を"1s"に変更して、再度シミュレーションを再生します。
ダッシュボードが更新される間隔が短くなり、先ほどよりリアルタイムで確認できるようになります。
ここまでで、統計ダッシュボードを使って、作業者の移動量と移動時間を確認できるようになりました。
最後に、統計ダッシュボードを使う上での注意点を説明します。
1つ目は、PCにかかる負荷についてです。
[間隔]を小さくすると、[間隔]が大きい時に比べて値を取得する頻度が上がるので、処理が多くなり、PCが重くなります。
また、レイアウトの規模が大きい場合、初期設定の"60s"でもPCが重くなる場合があります。
2つ目は、統計情報の精度についてです。
[間隔]を小さくすると、データ間の精度はよくなります。しかし、1つ目で説明したように、小さくしすぎるとPCに負荷がかかります。
また、レイアウトの規模によっては[間隔]を大きくしても精度に影響がない場合があります。
[間隔]は、使用しているPCのスペックやレイアウトの規模などに合わせて設定してください。
3つ目は、使用するチャートについてです。
今回の場合、表示するデータが「シミュレーション中の累計」なので、線グラフを使用しました。
稼働状況などの状態の遷移を表示する場合は円グラフを使うなど、用途に合ったグラフを使用してください。
以上で、「作業者の移動量・移動時間を確認しよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

作業者の立ち位置を変更しよう(1/2)

作業場所に人、AGV、フォークリフトの新しい立ち位置を追加する方法
（関連動画：AGVが製品をピック&プレースする時の位置を変更しよう）
https://youtu.be/RxD5ncDzQws
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_186_p1.zip

作業者の立ち位置を変更する方法について説明します。
AGVやフォークリフトも対象になります。
動画「AGVが製品をピック&プレースする時の位置を変更しよう」も参照ください。
eカタログモデルに、既に設定されている作業者の立ち位置について説明します。
作業場所として使用されるFeederProcess等には、作業者が製品を搬入・搬出する時の立ち位置が設定されています。
3Dワールドに矢印で表示されています。
作業者の立ち位置を移動させます。
FeederProcessを選択します。
[コンポーネントプロパティ]ウィンドウの[ResourceApproach]と[ResourceOffset]で、作業者の立ち位置を移動できます。
[ResourceApproach]をRight、Left、Front、Backと変更することで、作業者の立ち位置が、FeederProcessのアイコンを中心に、移動します。
[ResourceOffset]は、作業者の立ち位置を相対座標で設定できます。
[ResourceOffset]の[Tx]を1000に変更します。
立ち位置が離れたことがわかります。
[ShowResourceLocation]で、矢印の表示・非表示を変更できます。
シミュレーションを実行します。
FeederProcessから、製品を搬出する時、作業者が矢印の位置に立つことがわかります。
シミュレーションをリセットします。
MELSOFT Geminiバージョン1.410から、一部のeカタログモデルは、デフォルトで設定されている位置を追加しました。
ProcessNodeを選択します。
[コンポーネントプロパティ]ウィンドウの[DifferentResourceLocations]にチェックを付けることで、搬入する時と、搬出する時の位置を分けることができます。
[FlowInApproach]、[FlowInResourceLocation]は、搬入する時の位置、[FlowOutApproach]、[FlowOutResourceLocation]は、搬出する時の位置です。
[プロセス]タブを開きます。
[エディタ]-[プロセス]を選択します。
[Process #1]をクリックし、プロセスエディタを開きます。
[Transport: Any product as ProductIn]を選択すると、[ステートメントプロパティ]ウィンドウの[リソースポジションフレーム]にデフォルトでFlowInResourceLocationが設定されていることが分かります。
ProcessNodeを選択します。
シミュレーションを実行します。
搬入する時の位置と、搬出する時の位置が異なることがわかります。
シミュレーションをリセットします。
さらに、[WorkLocation]という位置も追加されています。
[ShowWorkLocation]にチェックを付けることで、3Dワールドに赤い矢印で表示できます。
[WorkLocation]の[Tx]に-500、[Rz]に45と入力します。
立ち位置が離れたことがわかります。
まだ、製品を搬入、または搬出する位置として設定されていないため、作業者は、[WorkLocation]で停止することはありません。
[プロセスステートメント]ウィンドウの[作業]-[リソースポジションフレーム]が[Null]の場合、[FlowInResourceLocation]が適用されるように、
Process Nodeのビヘイビア[TransportNode]の[デフォルトリソースポジションフレーム]で設定されています。
そのため、[リソースポジションフレーム]をNullにすると、自動的に[FlowInResourceLocation]になります。
新しい立ち位置を追加する方法について説明します。
ProcessNodeに新しく位置を追加します。
ProcessNodeを選択し、[プロセス]タブを開いている状態で、
[ヘルパーツール]グループの[フレームを作成]を選択します。
フレームとは、3Dワールド上で、位置と方向を定義する基準点です。
[フレームを作成]ウィンドウの[新しいフレーム名]に名前を入力します。
名前に、日本語や記号が含まれている、または、同じ名前のプロパティが存在する場合、フレームを追加できません。
[新しいフレーム名]に、NewInLocationと入力します。
[フレームの位置]で、相対座標を指定できます。
既存のフレームの座標を参考にする場合、[ここからロケーションをコピー]で、フレームを選択します。
WorkLocationを選択します。
[フレームの位置]に自動的に座標が入力されます。
[Tx]を500、[Rz]を135に変更します。
コンポーネントをコピー、貼り付けした場合、コンポーネント同士が一部設定を共有する、共有状態になることがあります。
コンポーネントが共有状態にある場合、[一意にする]にチェックを入れてフレームを追加することで、フレーム以外の設定も共有状態を解除できます。
これにより、選択したコンポーネントにのみフレームを追加できるようになります。
[フレームを作成]を選択することで、新しいフレームを追加できます。
[閉じる]を選択し、[フレームを作成]ウィンドウを閉じます。
[出力]ウィンドウに、フレームと、追加した場所の名前が表示されます。
3Dワールドに、フレームが表示されない場合、3Dワールドツールバーの[フレームタイプ]を展開し、フレームにチェックを付けます。
[フレームタイプ]アイコンが透明な場合、機能は無効となっているため、アイコンを選択し、有効にする必要があります。
3Dワールドに、フレームが表示されたことがわかります。
フレームの+X軸方向が、作業者の正面です。
[コンポーネントプロパティ]ウィンドウで、NewInLocationの座標を変更できます。
フレームの削除は、[モデリング]タブでのみ可能なため、MELSOFT Gemini Essentialsを使用している方は注意が必要です。
[モデリング]タブで、フレームを追加する方法を説明します。
Essentialsライセンスでは、この機能を使用できないため、Professionalライセンス以上が必要です。
ProcessNodeを選択します。
[モデリング]タブを開きます。
[ジオメトリ]グループの[フィーチャ]を展開し、[その他]から[フレーム]を選択します。
[コンポーネントグラフ]ウィンドウ下段に、フレームが追加されたことがわかります。
[フィーチャプロパティ]ウィンドウで、名前と座標を変更できます。
[名前]を、NewOutLocationに変更します。
[座標]に数値を入力することで、フレームを移動できますが、[モデリング]タブ以外では、移動できません。
[モデリング]タブ以外で、移動できるようにする場合、設定を追加します。
[コンポーネントグラフ]ウィンドウ下段のRootを選択します。
[ジオメトリ]グループの[フィーチャ]を展開し、[トランスフォーム]を選択します。
トランスフォームフィーチャは、数式を使用し、子階層のフィーチャを変形、または、移動させることができます。
[コンポーネントグラフ]ウィンドウ下段のNewOutLocationを、トランスフォームにドラッグ＆ドロップします。
トランスフォームが親、NewOutLocationが子です。
トランスフォームを選択します。
[フィーチャプロパティ]ウィンドウの[数式]に、関数や、計算式を入力できます。
入力可能な関数は、[ヘルプ]タブ、ヘルプファイル、[式]-[関数]-[ベクトルおよび行列構築関数]で確認できます。
今回は、プロパティの値によって、NewOutLocationを移動させるため、関数は使用しません。
[モデリング]タブを開きます。
[プロパティ]グループの[プロパティ]を展開し、[ベーシック]から[行列]を選択します。
[プロパティ]ウィンドウの[名前]をNewOutLocationに変更します。
プロパティの値の変化によって、フィーチャまたは、ジオメトリの見た目が変化する場合、[再構築]にチェックを付ける必要があります。
[再構築]にチェックを付けることで、プロパティの値が変化するたびに、フィーチャ、または、ジオメトリを再構築します。
[コンポーネントグラフ]ウィンドウ下段のトランスフォームを選択します。
[数式]にNewOutLocationと入力することで、プロパティNewOutLocationの値によって、フレームNewOutLocationの位置が変化します。
[コンポーネントグラフ]ウィンドウのProcessNodeを選択し、[コンポーネントプロパティ]ウィンドウを表示します。
[NewOutLocation]が追加されたことがわかります。
[Tx]に500、[Ty]に1000、[Rz]に-135と入力し、3DワールドのNewOutLocationが移動することを確認します。
作業場所に位置を追加する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

作業者の立ち位置を変更しよう(2/2)

フレームを作業者の立ち位置に設定する方法
（リソースポジションフレーム、ResourcePickOffset、ResourcePlaceOffset、PickApproach、PlaceApproach）
https://youtu.be/qPzml_1rUGA
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_186_p2.zip

作業者の立ち位置を変更する方法について説明します。
本動画では、フレームを作業者の立ち位置に設定する方法について説明します。
「Location_after1.vcmx」を開きます。
ProcessNodeで実行している処理を確認します。
ProcessNodeを選択します。
[プロセス]タブ-[エディタ]グループ-[プロセス]を選択することで、実行する処理を確認・変更できます。
[Process#1]を選択します。
TransportInで、製品を搬入し、Workで、手を動かし、TransportOutで、製品を搬出しています。
TransportInを選択します。
[ステートメントプロパティ]ウィンドウの[リソースポジションフレーム]を変更することで、作業者が製品を搬入する時の立ち位置を設定できます。
NewInLocationを選択します。
同様に、TransportOutとWorkの[リソースポジションフレーム]で、作業者の立ち位置を変更できます。
TransportOutは、製品を搬出する時、Workは、作業者が作業する時の立ち位置です。
Workを選択します。
[ステートメントプロパティ]ウィンドウの[リソースポジションフレーム]をWorkLocationに変更します。
TransportOutを選択します。
[ステートメントプロパティ]ウィンドウの[リソースポジションフレーム]をNewOutLocationに変更します。
シミュレーションを実行します。
設定した位置で、製品を搬入し、作業し、搬出していることがわかります。
シミュレーションをリセットします。
すべての搬入・搬出する時の作業者の立ち位置を一括で変更する場合、作業者のコントローラーの設定を変更します。
HumanTransportControllerを選択します。
[コンポーネントプロパティ]ウィンドウの[LinkDefaults]タブを開きます。
[ResourcePickOffset]で、製品を搬出する時の作業者の立ち位置を、フレームから移動させることができます。
XYZ軸方向の距離を設定します。
フレームのXYZ軸が基準となります。
Xに、500と入力します。
[ResourcePlaceOffset]は、製品を搬入する時の作業者の立ち位置を示す相対座標です。
YとZに、1000と入力します。
シミュレーションを実行します。
すべての作業場所で、製品を搬入する時、搬出する時の、作業者の立ち位置が変化したことがわかります。
シミュレーションをリセットします。
作業者の立ち位置を個別に変更します。
[エディタ]グループの[フロー]を選択し、製品の搬送経路を表示します。
3Dワールドに、表示されている矢印が、製品の搬送経路を表します。
矢印のことをトランスポートリンクといいます。
トランスポートリンク上のアイコンは、製品の搬送方法を表します。
FeederProcessとProcessNodeの間のトランスポートリンクを選択します。
[プロパティ]ウィンドウに、[ResourcePickOffset]と[ResourcePlaceOffset]があります。
デフォルトでは、変更できませんが、[UseCustomParameters]にチェックを付けることで、変更が可能になります。
[UseCustomParameters]で変更可能になるプロパティのデフォルト値を、HumanTransportControllerの[LinkDefaults]タブで設定しています。
[PickApproach]で、製品を拾うための位置に移動することができます。
[PlaceApproach]で、製品を置くための位置に移動することができます。
[ResourcePickOffset]で、FeederProcessから、製品を搬出する時の作業者の立ち位置を移動させることができます。
[ResourcePlaceOffset]で、ProcessNodeに、製品を搬入する時の作業者の立ち位置を移動させることができます。
[ResourcePickOffset]と[ResourcePlaceOffset]の座標をすべて0に変更します。
シミュレーションを実行します。
製品をFeederProcessから搬出し、ProcessNodeに搬入するまでの作業者の立ち位置のみ、フレームの位置に戻ったことがわかります。
シミュレーションをリセットします。
作業者の立ち位置を変更する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

座標系について学ぼう

Geminiの3Dワールド上の座標系の解説
https://youtu.be/c9-KkBg-Un8

本動画では、MELSOFT Geminiにおける座標系について説明します。
コンポーネントの位置は、現在選択されている座標系と座標の値の組み合わせによって決定します。
Geminiには、ワールド座標系、親座標系、オブジェクト座標系の3つの座標系があります。
これらの座標系について順番に説明していきます。
まず、コンポーネントを配置します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Products and Containers]から、"Box"と"Euro Pallet"を3Dワールド上にドラッグ&ドロップします。
3Dワールド上の「Box」を選択します。
[コンポーネントプロパティ]ウィンドウの座標には、選択しているコンポーネントの原点の現在座標が表示されています。
コンポーネントの原点は、[ホーム]タブ-[マニピュレーション]-[移動]をクリックすると確認できます。
ワールド座標系は、3Dワールドの原点を基準とする座標系です。
3Dワールドの原点には、ワールド原点フレームが表示されています。
表示されていない場合は、[ファイル]-[オプション]-[ディスプレイ]にある[ワールド原点フレーム]にチェックを入れると表示されるようになります。
赤色の線がX軸、緑色の線がY軸、青色の線がZ軸を表しています。
親座標系は、アタッチしている親コンポーネントの原点を基準とする座標系です。
選択しているコンポーネントに親コンポーネントが存在しない場合は、ワールド座標系同様に3Dワールドの原点を基準とします。
「Box」に親コンポーネントを設定して、親座標系の時の座標を確認します。
3Dワールド上の「Box」を選択した状態で[ホーム]タブ-[階層]-[アタッチ]をクリックし、「Euro Pallet」を選択します。
「Box」の[コンポーネントプロパティ]ウィンドウから"座標"を"親"に変更すると、座標の値が親コンポーネントである「Euro Pallet」の原点からの距離に変わります。
オブジェクト座標系は、選択しているコンポーネントの現在の位置を基準とする座標系です。
オブジェクト座標系を使用した場合、コンポーネントを現在の位置に対して相対的に移動することができます。
以上で、「座標系について学ぼう」を終わります。
ご視聴ありがとうございました。

=================================================================================

自動倉庫を作ってみよう

eカタログを組み合わせて、自動倉庫を作る方法（棚の「Warehouse Shelf」、クレーンの「Stacker Crane」、クレーンを制御する「Single Rail Transport Controller」など）
https://youtu.be/ahb_inkUzb0

本動画では、自動倉庫を構築する際に使用する、eカタログのコンポーネントについて説明します。
まず初めに、"Warehouse Shelf"について説明します。
[eカタログ]ウィンドウ-[タイプ別モデル]-"PM Warehousing"から"Warehouse Shelf"を3Dワールド上にドラッグ&ドロップします。
このコンポーネントは、ラックの役割を果たすコンポーネントです。
[コンポーネントプロパティ]ウィンドウ-[既定]タブの"Preset"、または"Option"タブのプロパティを変更すると、「Warehouse Shelf」の外見が変化します。
"Preset"を変更する時にサイズが変わる場合は、確認のダイアログが出力します。
[既定]タブの他のプロパティについて説明します。
このタブの設定を変えることで、ラックの全体、またはラック1個当たりの大きさなどを変更できます。
"Tiers"は、段数の設定です。
"Bays"は、1段あたりの間口の数の設定です。
"BaysPerSupportBeam"は、ラックを区切る柱を間口何個に対して1つ配置するかの設定です。
設定した値が、"Bays"を割った時に小数点が生じる値の場合、コンポーネントのレイアウトが崩れてしまいます。
設定する値は、"Bays"の約数にしてください。
"BayWidth"は、間口1個当たりの幅の設定です。
"BayDepth"は、間口1個当たりの奥行きの設定です。
"BayHeight"は、間口1個当たりの高さの設定です。
"BayTilt"は、棚板の傾きの設定です。
"FrameWidth"は、正面から見た時の柱の幅の設定です。
"FrameThinkness"は、柱の奥行きの設定です。
"BeamsHeight"は、ラックの梁の厚さの設定です。
"FloorClearance"は、最下段の床と地面との距離の設定です。
"ProductOrinetation"は、製品がラックに置かれる時の角度の設定です。
"FlowInResourceLocation/FlowOutResourceLocation"は、「Warehouse Shelf」が設定する、リソースが製品をラックに入れる/棚から製品を取り出す時の位置です。
リソースが"Stacker Crane"の場合は適応されません。3Dワールド上の表示はそれぞれ1つだけですが、この設定は全てのラックに対して適応されます。
"ShowResourceLocation"は、3Dワールド上の"FlowInResourceLocation/FlowOutResourceLocation"の表示/非表示の設定です。
チェックを外して非表示にした場合でも、"FlowInResourceLocation/FlowOutResourceLocation"の設定は有効です。
次に、"Warehouse Shelfに記述されているプロセスについて説明します。
[プロセス]タブ-[エディタ]-[プロセス]をクリックし、"Buffer"のプロセスラベルをクリックして、"Buffer"ステートメントをクリックします。
"Buffer"ステートメントは、ラックへ入れる製品の種類やラックへ製品を入れる、またはラックから製品を取り出す時の順番などの設定を行います。
ステートメントの設定を[ステートメントプロパティ]ウィンドウから変更することで、扱う製品の制限や製品の取り出す順番を変更できます。
"AcceptAllProductTypes"は、受け入れる製品タイプについての設定です。チェックがついている場合は全ての製品タイプを受け入れることができます。
チェックを外し、"AcceptedProductTypes"や"AcceptedFlowGroups"を設定することで、受け入れる製品タイプを指定できます。
"BufferFeedMode"は、ラックに入っている製品をどこのラックから取り出すかの設定です。
"BufferNeedMode"は製品をラックへ入れる時に、どのラックへ入れるかの設定です。
"FIFO"はラックに入った順に製品を取り出します。
"LIFO"はラックに入った順の逆順で製品を取り出します。
"ClosestToZeroPosition"は、"ZeroPositionNode"に設定したコンポーネントに近い位置にあるラックから順に処理を行います。
"Chaotic"はランダムで処理を行います。
"LinerOrder"はラックの最下段から1段ごとに順番に製品を入れます。
"RandomStream"は、"BufferFeedMode"または"BufferNeedMode"が"Chaotic"の時に使用する、乱数生成時のシード値です。
同じシード値を指定した場合、毎回同じ計算がされます。
ZeroPositionNode"は、"ClosestToZeroPosition"を使用する時の基準とするコンポーネントを3Dワールド上のコンポーネントから選択して設定します。
"ParallelInput/OutputLimit"には、ラックの総容量以下の数値を設定します。同じプロセスフローに複数のラックが接続されていた場合、この数値分製品を処理した後、使用するラックを切り替えます。
次に、Stacker Craneについて説明します。
[eカタログ]ウィンドウ-[タイプ別モデル]-"PM Cranes"から、"Stacker Crane – Single Pallet"を3Dワールドにドラッグ&ドロップします。
Stacker Crane は4つありますが、一度に持つことのできる製品の数以外の仕様は同じです。
Stacker Craneを使用する時は、"Human"などと同様にTransport Controllerに接続して使用します。
[タイプ別モデル]-[PM Transport Controllers]から"Single Rail Transport Controller"を3Dワールド上にドラッグ&ドロップします。
[マニピュレーション]-[PnP]を選択した状態で3Dワールド上の「Stacker Crane – Single Pallet」をドラッグして「Single Rail Transport Controller」に近づけ、接続します。
Stacker Craneのプロパティについて説明します。
"CarrierPosition"は、PnP接続をした時の位置を基準として、Stacker Craneがトランスポートコントローラ上のどの位置にあるかの設定です。
"CradlePosition"は、Stacker Craneの荷台の高さの設定です、
"HandlerPosition"は、Stacker Craneのフォークの位置の設定です。
[RailWidth]は、Stacker Craneのレールの幅の設定です。
"CarrierWidth"は、Stacker Craneの幅の設定です。
"CarrierHeight"は、Stacker Craneの高さの設定です。
"CradleWidth"は荷台の幅の設定です。
"CradleLength"は、荷台の長さの設定です。
"HandlerWidth"は、フォークの幅の設定です。
"LiftMotor"は、リフトモーターの位置の設定です。
"SingleMast"は、Stacker Craneの柱の本数を1本にする設定です。
"TelescopicFork"はStacker Craneのフォークを、テレスコピック構造にする設定です。
次に、"AutoHoming"タブについて説明します。
このタブでは、AutoHoming機能についての設定を行います。
AutoHoming機能とは、アイドル状態が指定した時間続いた時に、指定した位置へクレーンが自動的に移動する機能です。
このタブのプロパティを設定することで、AutoHoming機能を有効にできます。
"Delay"には、数値を設定します。接続しているクレーンが設定した秒数アイドル状態を続けた時、Stacker Craneの位置は"CarrierPosition"、荷台の位置は"CradlePosition"へ移動します。
"Delay"が0の場合、AutoHoming機能は無効になります。
"Read Current Joint Values"は、押下すると現在のStackerCraneと荷台の位置を測定し、その値をこのタブの"CarrierPosition/CradlePosition"に上書きする機能です。
"Speeds"タブでは、シミュレーション中にStacker Craneと荷台、フォーク部分が移動する時の速度(Speed)と加速度(Acceleration)を設定します。
次に、"Single Rail Transport Controller"について説明します。
このコンポーネントは、接続しているStacker Craneを制御するコントローラです。
1つの"Single Rail Transport Controller"に最大2つのStacker Craneを接続できます。
接続したインターフェースによって、クレーンAとクレーンBに区別します。
[既定]タブについて説明します。
「Single Rail Transport Controller」をクリックして、[コンポーネントプロパティ]ウィンドウ-[既定]タブを表示します。
"TrackLength"は、コントローラの長さの設定です。接続しているクレーンの移動範囲になります。
[RailWidth]は、コントローラの幅の設定です。
[RailHeight]は、コントローラの高さの設定です。
"SafetyClearance"は、クレーンが2台接続していた時の、クレーン間で最低限設ける必要のある間隔の設定です。
"CheckLimits"はチェックを入れると、接続しているクレーンがレールの軌道から外れた時に、シミュレーションを一時停止してエラーメッセージを出力するようになります。
"ShowTopRail"はチェックを入れると、コントローラのトップレールが表示されます。
トップレールの高さは、チェックを入れた後に表示される"TopRailHeight"で設定します。
"Auto Configure Linksクリックすると、複数のクレーンがレールに接続されている場合、リンクのソースノードと目的地ノードに、クレーンAとクレーンBのどちらか近い方をそれぞれ関連付けます。
[LinkDefaults]タブについて説明します。
[コンポーネントプロパティ]ウィンドウ-[LinkDefaults]タブを表示します。
これらプロパティ値は、トランスポートリンクの製品をピック/プレースの作業時間のデフォルト設定です。
"GraspTime/ReleaseTime"は、クレーンが製品をラックへ入れる、またはラックから製品を取り出す際の作業時間の設定です。
この時間には、クレーンのフォークが伸縮する時間は含まれません。
"PostPickWaitTime"は、製品をピックした後に次のタスクへ移るまでの待ち時間の設定です。
この設定は、クレーンの容量が既にいっぱいである場合や、クレーンに既に他のタスクが割り当てられている場合は適用されません。
コンベアなどでピッキングを行うプロセスに、製品が追加で入るのを待ってから、製品を輸送する場合などで使用します。
最後に、製品の輸送をクレーンに割り当てた時の設定について説明します。
[タイプ別モデル]-[PM Flow Components]から"Feeder Process"を3Dワールド上にドラッグ&ドロップします。
[プロセス]タブ-[エディタ]-[フロー]をクリックします。
3Dワールド上の「Single Rail Transport Controller」上のひし形アイコンをクリックし、"Feeder"のプロセスラベル-"Buffer"のプロセスラベルと順にクリックして"Feeder-Buffer"フローを作成します。
"Feeder-Buffer"間のひし形アイコンをクリックして、トランスポートリンクのプロパティを開きます。
"Priority"は、このトランスポートの優先度を設定します。
この設定は他のトランスポートリンクや"Work"ステートメントの設定とも共有され、数値が小さいほど優先度は高くなります。
"Use Crane"は、使用するクレーンの設定です。
"Any"を設定した場合は、コントローラが自動的に最も近いクレーンに製品の輸送作業を割り当てます。
"UseCustomParameters"は、トランスポートリンクで"GraspTime/ReleaseTime/PostPickWaitTime"の値を変更したい場合に、有効にします。
"インプリメンタ"は、このトランポートリンクを割り当てるコントローラの設定です。
以上で、「自動倉庫を作ってみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

自動ドアを作ってみよう(1/2)

人が近づくと開き、離れると閉じる、自動ドアを作る方法（Rolling Steel Door v2、Pathway Area Sensor）
https://youtu.be/Ub_dJEZSDFM
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_148_p1.zip

eカタログのモデルを組み合わせて、自動ドアを表現する方法を説明します。
設定が完了すると、人の通行を検知し、開閉する自動ドアを表現できます。
付属ファイル「AutomaticDoor_before.vcmx」を開きます。
製品を生成するFeeder Process、目的地となるSink Process、製品を運ぶHuman、人を制御するHuman Transport Controllerが配置されていることを確認します。
人が移動可能な範囲を指定するため、[eカタログ]のモデルを配置します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Navigation]から、[Pathway Area]を3つ、3Dワールドにドラッグ＆ドロップします。
人の通行を検知するため、センサーを配置します。
[PM Navigation]から、[Pathway Area Sensor]を3Dワールドにドラッグ＆ドロップします。
ドアを配置します。
[Facilities - Factory]、[Visual Components]から、[Rolling Steel Door v2]を3Dワールドにドラッグ＆ドロップします。
[Pathway Area]のサイズを変更します。
[Pathway Area]を2つ選択し、[コンポーネントプロパティ]ウィンドウの[AreaLength]を5000に変更します。
サイズ変更した[Pathway Area]を[Feeder Process]と[Sink Process]が中央に配置されるようにそれぞれ移動します。
2つの[Pathway Area]をつなぐように3つ目の[Pathway Area]のサイズを変更し、配置します。
[Pathway Area]を選択し、[コンポーネントプロパティ]ウィンドウの[AreaLength]を3000、[AreaWidth]を1000に変更します。
[マニピュレーション]グループの[インタラクティブ]を選択し、[Pathway Area]の色が濃い部分をドラッグすることでもサイズを変更できます。
[Rolling Steel Door v2]を中央の[Pathway Area]へ配置します。
[Rolling Steel Door v2]を選択します。
角度を変更するため、座標Rzを90に変更します。
[マニピュレーション]グループの[移動]を選択し、中央の[Pathway Area]へ配置します。
人をコントローラーで制御するため、人とコントローラーを接続します。
[接続]グループから[インターフェース]を選択します。
[Human Transport Controller]を選択することで、インターフェースエディタを表示できます。
[Human Transport Controller]で[Resources]を選択し、[Human (Anna)]の[PMResource]右側の丸をクリックすることで、接続できます。
人が移動する範囲を設定するため、[Human Transport Controller]で[Pathways]を選択します。
[Pathway Area]の接続先が表示されるため、全て選択し接続します。
クリックではなく、ドラッグすることでも、接続できます。
[インターフェースに接続]ウィンドウから接続する[コンポーネント]と[インターフェース]を選択すると、[このリストからインターフェースに接続]に接続可能なインターフェースが表示されます。
リストの中から選択することでも接続できます。
コントローラーの[コンポーネントプロパティ]ウィンドウを表示し、[Connect All Pathways]、[Connect All Resources]を選択することで、接続可能なインターフェースと一括で接続できます。
人が製品を搬送する流れを設定します。
[プロセス]タブの[エディタ]グループから[フロー]を選択します。
[プロセスフローエディタ]ウィンドウの[フローグループ番号1]を選択します。
人が[Feeder]から[Sink]へ製品を搬送するため、[Human Transport Controller]のアイコンを選択します。
[Feeder]のプロセスラベル、[Sink]のプロセスラベルの順に選択します。
シミュレーションを実行します。
人が[Feeder]から[Sink]へ製品を搬送しますが、ドアは開きません。
シミュレーションをリセットします。
ドアが自動で開く設定にするため、人の通行をセンサーで検知します。
人の通行を検知する範囲を設定するため、中央の[Pathway Area]と[Pathway Area Sensor]を接続します。
[ホーム]タブの[接続]グループから[インターフェース]を選択します。
[Pathway Area Sensor]を選択します。
[Pathway Area Sensor]の[Pathways]と、中央の[Pathway Area]の[AreaSensor]を選択し接続します。
[閉じる]を選択します。
人が通るときにドアが開く設定をします。
[接続]グループの[シグナル]を選択します。
シミュレーションを実行します。
[Rolling Steel Door v2]の[IN_J1_Action]をオンにすると、ドアが開き、オフにすると、ドアが閉じます。
[Pathway Area Sensor]の[ResourceDetected]は、人を検知しオンオフを切り替えています。
シミュレーションをリセットします。
2つのシグナルを接続し、人が通るたびにドアが開閉する設定をします。
[Pathway Area Sensor]の[ResourceDetected]と[Rolling Steel Door v2]の[IN_J1_Action]を接続します。
[閉じる]を選択します。
シミュレーションを実行します。
人が通るたびにドアが開閉することが分かります。
人がドアの柱を貫通する、またはドアの端を通行する場合、[Pathway Area]の中央を通行する設定に変更します。
シミュレーションをリセットします。
中央の[Pathway Area]を選択し、[コンポーネントプロパティ]ウィンドウの[CenterlineConnect]にチェックを付けます。
再度シミュレーションを実行すると、人は[Pathway Area]の中央を通ります。
人の通行が完了していない状態で、ドアが開閉する場合、中央の[Pathway Area]のサイズを変更します。
シミュレーションをリセットします。
中央の[Pathway Area]を選択します。
[コンポーネントプロパティ]ウィンドウの[AreaLength]を5000に変更します。
シミュレーションを実行します。
Pathway Areaへの出入りが、ドアの開閉のトリガーとなっていることがわかります。
シミュレーションをリセットします。
[コンポーネントプロパティ]ウィンドウで、ドアの開閉時間を変更することもできます。
ドアを選択します。
[コンポーネントプロパティ]ウィンドウの[DoorMotionTime]を「1」に変更します。
シミュレーションを実行します。
ドアが1秒で開閉することが分かります。
シミュレーションをリセットします。
[Pathway Area]と、別のコンポーネントが重なっている場合、エラーが発生する可能性があります。
障害物を回避できる経路が見つからないため、障害物を回避しないことを示すエラーです。
コントローラーは、3Dワールドに存在するすべてのコンポーネントを障害物として認識しています。
コントローラーの障害物のリストからドアと目的地を除外します。
[Human Transport Controller]を選択します。
[コンポーネントプロパティ]ウィンドウの[ExcludeObstacles]を選択することで、プラスアイコンが表示されます。
プラスアイコンを選択し、表示される[Add'ExcludeObstacles'items]ウィンドウで、[Feeder Process]、[Sink Process]、[Rolling Steel Door v2]を選択します。
[Add'ExcludeObstacles'items]ウィンドウを閉じます。
[出力]ウィンドウ内で右クリックをします。
[Clear]を選択し、エラーメッセージを削除します。
シミュレーションを実行します。
[出力]ウィンドウにエラーは表示されず、ドアが開閉することがわかります。
シミュレーションをリセットします。
eカタログのモデルを組み合わせて、自動ドアを表現する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

自動ドアを作ってみよう(2/2)

コンベア上の製品が流れてくると開き、通り過ぎると閉じる、自動ドアを作る方法（Rolling Steel Door v2）
https://youtu.be/8eoiJQudqKE
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_148_p2.zip

シグナルを使用し自動ドアを制御する方法について説明します。
付属ファイル「AutomaticDoor prt2_before.vcmx」を開きます。
設定が完了すると、製品を検知し、開閉するドアを表現できます。
製品を搬送できるように設定します。
[プロセス]タブの[エディタ]グループから[プロセス]を選択します。
[プロセス]は製品が移動する経路の中継地点の作業内容を設定できます。
中継地点の名前が重複しているため、変更します。
右側の[Process #1]のプロセスラベルを選択し、プロセスを表示します。
[ルーチンプロパティ]ウィンドウの[名前]を、[Process #2]に変更します。
プロセスを閉じます。
[Feeder]から[Sink]へ製品を搬送する流れを設定します。
[エディタ]グループの[フロー]を選択します。
[フロー]は製品を搬送する流れや、搬送方法を設定できます。
[プロセスフローエディタ]ウィンドウの[フローグループ番号1]を選択します。
[Feeder]、[ToConveyor]、[Process #1]、[Process #2]、[FromConveyor]、[Sink]の順にプロセスラベルを選択します。
[エディタ]グループの[フロー]を選択し、フローステップを非表示にします。
シミュレーションを実行します。
[Feeder]で生成された製品が、コンベア上を移動後、[Sink]へ搬送されません。
シミュレーションをリセットします。
製品を[Sink]へ搬送するため、プロセスを設定します。
[エディタ]グループの[プロセス]を選択します。
[Process #1]を選択します。
プロセスの[TransportIn]を選択します。
[ステートメントプロパティ]ウィンドウの[ソース]が[前のプロセスから]になっています。
[ToConveyor]の[TransportOut]を確認すると、[目的地]は[コンポーネントコンテナへ]です。
製品は[Conveyor]のコンポーネントコンテナへ搬出されます。
コンポーネントコンテナは、コンベアや装置等が製品を一時保管する箱の設定です。
[Conveyor]のコンポーネントコンテナは、製品を一時保管して、[Conveyor]上に流します。
次に、[Process #1]に搬入するため、[Process #1]にある[TransportIn]の[ステートメントプロパティ]ウィンドウの[ソース]を[コンポーネントコンテナから]に変更します。
[ToConveyor]のプロセスを閉じます。
[Process #1]のプロセスの[TransportOut]を選択します。
製品をコンベアへ搬送するため、[ステートメントプロパティ]ウィンドウの[目的地]を[コンポーネントコンテナへ]に変更します。
[Process #2]を選択し、[Process #1]と同様に変更します。
[エディタ]グループの[プロセス]を選択し、プロセスラベルを非表示にします。
シミュレーションを実行します。
[Sink]まで搬送されることが分かります。
ドアが開くように設定します。
シミュレーションをリセットします。
製品が[Process #1]に到達後、ドアが開くシグナルを送信するように設定します。
[Process #1]のプロセス、[TransportIn]を選択します。
[ステートメント]を選択します。
[その他のステートメント]から[シグナル送信]を選択します。
[シグナル送信]は、指定したシグナルの値を変更できます。
[ステートメントプロパティ]ウィンドウの[コンポーネント]から[Rolling Steel Door v2]を選択します。
ドアを開くため、[シグナル]から[IN_J1_Up]を選択します。
[値]に「True」と入力します。
ドアが完全に開くまで製品を流さないように設定します。
[ステートメント]を選択します。
[その他のステートメント]から[シグナル待機]を選択します。
[シグナル待機]は特定のシグナルが条件を満たすまで次のステートメントを実行しません。
[ステートメントプロパティ]ウィンドウの[コンポーネント]から[Rolling Steel Door v2]を選択します。
ドアが完全に開くまで待機するため、[シグナル]から[OUT_J1_UpState]を選択します。
[コンディション]に「True」と入力します。
ドアが完全に開いた時、ドアを開くシグナルをオフにします。
[SendSignal]を選択し、コピーします。
[WaitSignal]と[TransportOut]の間に貼り付け、[ステートメントプロパティ]ウィンドウの[値]を「False」に変更します。
製品が[Process #2]に到達後、ドアが閉じるシグナルを送信するように設定します。
[Process #2]のプロセス、[TransportIn]を選択します。
[ステートメント]を選択します。
[その他のステートメント]から[シグナル送信]を選択します。
[ステートメントプロパティ]ウィンドウの[コンポーネント]から[Rolling Steel Door v2]を選択します。
ドアを閉じるため、[シグナル]から[IN_J1_Down]を選択します。
[値]に「True」と入力します。
製品をコンベアへ搬送し、ドアが完全に閉じた状態を示すシグナルがオンになった後、ドアを閉じるシグナルをオフにします。
[TransportOut]を選択し、[TransportOut]の後にステートメントを追加します。
[ステートメント]を選択します。
[その他のステートメント]から[シグナル待機]を選択します。
[ステートメントプロパティ]ウィンドウの[コンポーネント]から[Rolling Steel Door v2]を選択します。
ドアが完全に閉じた状態を示すシグナルがオンになるまで待機するため、[シグナル]から[OUT_J1_DownState]を選択します。
[コンディション]に「True」と入力します。
ドアが完全に閉じた時、ドアが閉じるシグナルをオフにします。
[SendSignal]を選択し、コピーします。
[WaitSignal]の後に貼り付け、[ステートメントプロパティ]ウィンドウの[値]を「False」に変更します。
プロセスを閉じます。
シミュレーションを実行します。
製品が[Process #1]へ到達後ドアが開き、[Process #2]に製品が到達後ドアが閉じることが分かります。
シグナルの状態を確認します。
[ホーム]タブの[接続]グループにある[シグナル]を選択します。
[Rolling Steel Door v2]を選択することでシグナルエディタを表示できます。
ドアが完全に閉じている時、[Rolling Steel Door v2]の[OUT_J1_DownState]はオン、[IN_J1_Down]はオフです。
[IN_J1_Up]がオンになるとドアが開き、[OUT_J1_DownState]がオフになります。
ドアが完全に開くと、[OUT_J1_UpState]がオンになり、[IN_J1_Up]がオフになります。
[IN_J1_Down]がオンになるとドアが閉じ、[OUT_J1_UpState]がオフになることが分かります。
[接続]グループの[シグナル]の選択を解除します。
シミュレーションをリセットします。
シグナルを使用し自動ドアを制御する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

条件を満たすまで待機するプログラムを作ってみよう

条件を満たすまで待機する設定方法
（プロパティ取得、プロパティコンディションを待機）
https://youtu.be/hA_Qa6ScpgQ
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_084.zip

本動画では、プロパティが特定の値になるまで待機するプログラムの作成方法について説明します。
他のコンポーネントのプロパティを取得する"プロパティ取得"ステートメントと、プロパティが指定の条件を満たすまで待機する"プロパティコンディションを待機"ステートメントを使って作成します。
まず初めに、「条件を満たすまで待機するプログラムを作ってみよう.vcmx」を開きます。
シミュレーションを再生して動作を確認します。
「Pallet」の上に「Box」を配置し、それをトラックの中へ積み込みます。
現在の設定では、「Inline_or_Decline」上のコンポーネントの有無にかかわらず「Pallet」を輸送するため、「Incline_or_Decline」前が「Pallet」で混雑しています。
手前側ロボットがパレタイジングしているプロセス内容を修正して、「Incline_or_Decline」にコンポーネントがない時に製品を輸送するように変更します。
「Incline_or_Decline」の現在のコンポーネントの数は、"Statistics"ビヘイビアの"PartsCurrent"というプロパティで記録しています。他のコンポーネントのプロパティを使用する時は、"プロパティ取得"ステートメントを使用します。
[プロセス]タブ-[エディタ]-[プロセス]をクリックします。
「Inline Process #6」の"Palletizing"をクリックします。
"State:Idle"を選択した状態で"ステートメント"-"プロパティ取得"をクリックします。
"プロパティ取得"ステートメントは、コンポーネントを指定し、指定したコンポーネントのどのプロパティを取得するか設定します。
取得した値を、"プロパティ名"で設定した名前のプロパティに保存し、他のステートメントで使用できるようにします。
今回の場合、「Inline_or_Decline」のStatisticsビヘイビアのプロパティである"PartsCurrent"を取得し、"PartsCount"に格納します。
追加された"GetProperty:~"を選択します。
[ステートメントプロパティ]ウィンドウから"選択したコンポーネント"に"Inline_or_Decline"、"選択したビヘイビア"に"Statistics"、"選択したプロパティ"に"PartsCurrent"、"プロパティ名"に"PartsCount"を設定します。
"State:Blocked"を選択した状態で"ステートメント"-"プロパティコンディションを待機"をクリックします。
"プロパティコンディションを待機"ステートメントは、"変数名"に指定した変数が[コンディション]に設定した値になるまで待機します。
追加された"WaitPropertCondition:~"を選択します。
[ステートメントプロパティ]ウィンドウから"変数名"を"PartsCount"、[コンディション]を"0"に変更します。
これで、「Inline_or_Decline」の現在のコンポーネントの数を取得して、"0"になるまで待機してから「Pallet」を輸送するように設定できました。
設定を確認しやすくするために、奥側ロボットがパレタイジングしているプロセス内容を変更します。
「Inline Process」の"Palletizing"をクリックします。
"TransportIn"を選択した状態で、"ステートメント"-"ディレイ"をクリックします。
追加された"Delay:~"を選択します。
[ステートメントプロパティ]ウィンドウから"分布"を"60"に変更します。
最後に、Statisticsビヘイビアを更新するインターバルを設定します。
[ホーム]タブをクリックします。
[統計情報]-[間隔]は、統計情報であるStatisticsビヘイビアを更新する時間を設定します。
初期設定は60となっていて、60秒ごとにStatisticsビヘイビアを更新します。
[間隔]を"1"に変更します。
シミュレーションを再生します。
「Incline_or_Decline」上のワークが0になったとき、「Inline Process #6」からワークが搬出されるようになりました。
以上で、「条件を満たすまで待機するプログラムを作ってみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

処理の回数を数えよう

プロセス内で処理する回数をカウントアップする方法（ルーチン変数、変数を割り当てるステートメント、IFステートメント）
https://youtu.be/JahbAzxP3Dg
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_175.zip

処理の回数を数える方法について説明します。
事前ファイル「CountUp_before.vcmx」を開きます。
シミュレーションを実行します。
棚に格納された製品を搬送し、机で作業を行い、コンベアに搬出しています。
シミュレーションをリセットします。
今回は、机に製品を搬入した回数を数えるため、机で行っている処理を変更します。
[プロセス]タブ-[エディタ]グループ-[プロセス]を選択することで、実行する処理を設定できます。
[ManualProcess]を選択します。
TransportInで製品を搬入、Workで人が作業、TransportOutで製品を搬出しています。
搬入した製品には、ManualProcessでのみ使用可能な名前が付与されます。
TransportInを選択し、[ステートメントプロパティ]ウィンドウの[製品変数名]で確認できます。
名前は、ProductInです。
製品を搬入した回数を数えるため、変数を追加します。
プロセスを選択し、[ルーチンプロパティ]ウィンドウを表示します。
現在設定しているプロセスでのみ、使用可能な変数を追加できます。
[新規変数を追加]を選択することで、4種類の変数を追加できます。
今回は、回数を数えるため、整数変数を選択します。
名称をcountに変更します。
countの初期値は、0です。
シミュレーションをリセットすることで、変数の値が初期値に戻ります。
値をカウントアップします。
新規ステートメントを追加するため、[ステートメント]アイコンを選択します。
[フローコントロールステートメント]から[変数を割り当てる]を選択します。
変数を割り当てるステートメントは、指定した変数に値を入力できます。
AssignをWorkの下にドラッグします。
[ステートメントプロパティ]ウィンドウの[ターゲットプロパティ]は、変数の名前、[数式値]は、入力する値です。
[ターゲットプロパティ]に、countと入力します。
[数式値]にcount+1と入力することで、実行するたびに、countの値に1加算されます。
変数を[出力]ウィンドウに表示します。
[ステートメント]アイコンを選択します。
[その他のステートメント]から[プリント]を選択します。
プリントステートメントは、[出力]ウィンドウにメッセージを表示できます。
PrintをTransportInの下にドラッグします。
[ステートメントプロパティ]ウィンドウの[メッセージ]に、表示する文字を入力できます。
入力した文字を表示する場合、ダブルクォーテーションマークではさむ必要があります。
変数の値を表示する場合、ダブルクォーテーションマークは必要ありません。
[メッセージ]に、countと入力します。
シミュレーションを実行します。
ManualProcessを選択し、[ルーチンプロパティ]ウィンドウを表示します。
[ルーチンプロパティ]ウィンドウでは、シミュレーション中の変数の現在値を確認できます。
人が作業を完了した時、countの値が1増加することがわかります。
[出力]ウィンドウにcountの値が表示されます。
シミュレーションをリセットします。
countの値は、0に戻ります。
countが5の場合のみ、人の作業を実行します。
countが5の場合、作業を実行し、5以外の場合、変数をカウントアップします。
[ステートメント]アイコンを選択します。
[フローコントロールステートメント]から[IF]を選択します。
IFステートメントは、条件を満たしている場合と、満たしていない場合の、2パターン処理を設定できます。
条件を満たしている場合の処理はThen、満たしていない場合の処理はElseに設定します。
IfをPrintの下にドラッグします。
[ステートメントプロパティ]ウィンドウの[コンディション]に条件を入力できます。
count==5と入力します。
countが5の場合、作業を実行するため、WorkをThenにドラッグします。
countが5以外の場合、カウントアップするため、AssignをElseにドラッグします。
作業後、製品の色を変更します。
[ステートメント]アイコンを選択します。
[プロセスステートメント]から[ノードマテリアルを設定]を選択します。
ノードマテリアルを設定ステートメントは、指定した製品の色を変更できます。
SetNodeMaterialをWorkの下にドラッグします。
製品は、[ステートメントプロパティ]ウィンドウの[製品変数名]で指定できます。
搬入した製品の名前は、ProductInです。
[マテリアル]で、変更後の色を指定できます。
yellowを選択します。
作業を定期的に行う場合、countの値をリセットする必要があります。
Assignを選択し、コピーします。
Thenを選択し、貼り付けます。
Assignを選択し、[ステートメントプロパティ]ウィンドウの[数式値]に0と入力します。
シミュレーションを実行します。
製品を棚から机、机からコンベアに搬送していることがわかります。
5個目の製品を搬入した時、作業は行いません。
5個目の製品を机に搬入した時、countは5になります。
しかし、次にIFステートメントの条件が評価されるのは、5個目の製品を搬出し、6個目の製品を搬入した後です。
条件がcount == 5の場合、6個目の製品を机に搬入した時、作業を実行することがわかります。
シミュレーションをリセットします。
処理の回数を数える方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

処理を繰り返そう(1/2)

条件を設定して処理を繰り返す方法（WHILE、新規変数を追加）
（関連動画：処理の回数を数えよう）
https://youtu.be/D6ALwKAR_TQ
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_180_p1.zip

プロセスモデリングで、処理を繰り返す方法について説明します。
事前ファイル「while_before.vcmx」を開きます。
シミュレーションを実行します。
人が白いブロックを机に搬入し、作業します。
作業後、オレンジのブロックを作成、搬出後、白いブロックを削除します。
シミュレーションをリセットします。
扱う製品と、机で実行される処理を確認します。
[プロセス]タブを開きます。
[エディタ]グループの[製品]を選択します。
製品は、名前と見た目を製品タイプに登録します。
製品タイプは、フローグループで分かれており、フローグループごとに搬送経路を設定できます。
フローグループと製品タイプは、[製品タイプエディタ]ウィンドウで確認できます。
白いブロックの名前はProduct、オレンジのブロックの名前はPartです。
[エディタ]グループの[プロセス]を選択することで、実行する処理を設定できます。
[ManualProcess]を選択します。
TransportInでProductを搬入し、Workで作業します。
CreateとTransportOutでPartを作成し、搬出します。
RemoveでProductを削除します。
実行する処理を変更します。
Productの搬入後、Partの生成と搬出を5回繰り返します。
Ctrlキーを押した状態で、Work、Create、TransportOutを選択します。
右クリック、[コピー]を選択します。
TransportOutを選択し、右クリック、[貼り付け]を選択します。
処理を繰り返す回数、コピーと貼り付けを行います。
シミュレーションを実行します。
Productの搬入後、Partの生成と搬出を5回繰り返していることがわかります。
シミュレーションをリセットします。
繰り返し処理を設定する場合、プロセスの行数を減らすことができます。
Partを1つ生成、搬送する設定に戻します。
Shiftキーを押しながら一括選択し、右クリック、[削除]を選択します。
処理を繰り返した回数を記録するため、変数を追加します。
処理の回数を記録する方法の詳細は、動画「処理の回数を数えよう」を参照してください。
ManualProcessを選択し、[ルーチンプロパティ]ウィンドウを表示します。
[新規変数を追加]で、整数変数を選択します。
[名称]を、countに変更します。
[ステートメント]アイコンを選択します。
[フローコントロールステートメント]から[WHILE]を選択します。
WHILEステートメントは、条件を満たしている間、範囲内の処理を繰り返し実行できます。
CreateとTransportOutを、Whileの<empty>にドラッグします。
Whileは、WorkとRemoveの間です。
[ステートメントプロパティ]ウィンドウの[コンディション]に、処理を実行する条件を設定できます。
count<5と入力します。
countの値を加算します。
[ステートメント]アイコンを選択します。
[フローコントロールステートメント]から[変数を割り当てる]を選択します。
変数を割り当てるステートメントは、指定した変数に値を入力できます。
Assignを、TransportOutの下にドラッグします。
[ステートメントプロパティ]ウィンドウの[ターゲットプロパティ]は、変数の名前、[数式値]は、入力する値です。
[ターゲットプロパティ]に、countと入力します。
[数式値]にcount+1と入力することで、実行するたびに、countの値に1加算されます。
製品を削除後、countの値を初期値に戻します。
Assignをコピーし、Removeの下に貼り付けます。
貼り付けたAssignを選択し、[ステートメントプロパティ]ウィンドウで、[数式値]を0に変更します。
変数を[出力]ウィンドウに表示します。
[ステートメント]アイコンを選択します。
[その他のステートメント]から[プリント]を選択します。
プリントステートメントは、[出力]ウィンドウにメッセージを表示できます。
PrintをAssign count = count+1の下にドラッグします。
[ステートメントプロパティ]ウィンドウの[メッセージ]に、表示する文字を入力できます。
入力した文字を表示する場合、ダブルクォーテーションマークで、はさむ必要があります。
変数の値を表示する場合、ダブルクォーテーションマークは、必要ありません。
[メッセージ]に、countと入力します。
シミュレーションを実行します。
PartをSinkで削除した時、[出力]ウィンドウに、エラーメッセージが表示されます。
WHILEステートメントを使用し、製品を生成する場合、注意が必要です。
製品変数の値は、プロセスの最後の行を実行後、リセットされます。
WHILEステートメント内で、トランスポートアウトステートメントを実行する場合、繰り返し処理が終了し、最後の行を実行するまで、製品変数の値はリセットされません。
搬送先のトランスポートインステートメントの完了を待たず、搬送元のトランスポートアウトステートメントは完了し、次のステートメントに進みます。
製品の情報がリセットされる前に、次の周の製品作成、またはトランスポートインステートメントにより、次の製品が同じ製品変数に追加されます。
搬送先のトランスポートインステートメントが完了し、製品を削除する時、製品変数は、製品の情報を2つ所持しています。
1つ目の製品を削除した時、2つ目の製品の情報も削除されます。
2つ目の製品に対してトランスポートアウトステートメントを実行する時、製品変数には、製品の情報がないため、「製品が破棄されました」というエラーメッセージが表示されます。
シミュレーションをリセットします。
次の製品を生成する前に、製品変数の値をリセットします。
[出力]ウィンドウで、右クリックし、[Clear]を選択することで、メッセージを削除できます。
Assign count=count+1を選択し、コピーし、貼り付けます。
[ステートメントプロパティ]ウィンドウの[ターゲットプロパティ]にPartと入力します。
[数式値]を空欄にすることで、製品変数の値をリセットできます。
シミュレーションを実行します。
製品変数Partに、複数の製品の情報が、格納されることはないため、エラーメッセージは表示されません。
[出力]ウィンドウには、countの値が表示されます。
Partを5個搬出後、新しいProductの搬入を開始することがわかります。
シミュレーションをリセットします。
特定の条件を満たすまで、処理を開始しないステートメントを追加することでも、製品変数に、複数の製品の情報を格納しないようにできます。
Assign Partを選択します。
右クリック、[削除]を選択します。
WorkをCreateの上にドラッグします。
シミュレーションを実行します。
while内の処理を1通り実行し、whileの先頭に戻ります。
作業ステートメントは、作業者が作業場所に到着し、任意の時間、動作することが完了条件です。
Partの搬送中は、人が作業場所に移動できません。
作業が完了していないため、次の製品の情報は格納されません。
製品変数Partに、複数の製品の情報が、格納されることはないため、エラーメッセージは表示されません。
シミュレーションをリセットします。
プロセスモデリングで、処理を繰り返す方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

処理を繰り返そう(2/2)

繰り返し処理を制御する方法（BREAK、CONINUE）
https://youtu.be/bxfra4Xy2to
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_180_p2.zip

プロセスモデリングで、処理を繰り返す方法について説明します。
本動画では、繰り返し処理を制御する方法について説明します。
動画「処理を繰り返そう(1/2)」の続きから設定します。
付属ファイル「while_after1.vcmx」を開きます。
特定の条件を満たした時、繰り返し処理を途中で強制終了する方法について説明します。
現在、Partの生成と搬出を5回繰り返した後、繰り返し処理を終了しています。
同様の動作を、別の方法で行います。
[プロセス]タブ-[エディタ]グループ-[プロセス]を選択します。
ManualProcessを選択し、[ルーチンプロパティ]ウィンドウを表示します。
繰り返し条件を、変更します。
Whileを選択します。
[ステートメントプロパティ]ウィンドウの[コンディション]に、Trueと入力することで、シミュレーション実行中、処理を繰り返し続けます。
繰り返し処理を終了する条件を設定します。
[ステートメント]アイコンを選択します。
[フローコントロールステートメント]から[IF]を選択します。
IFステートメントは、条件を満たしている場合と、満たしていない場合の、2パターン処理を設定できます。
条件を満たしている場合の処理はThen、満たしていない場合の処理はElseに設定します。
IFをWorkの上にドラッグします。
[ステートメントプロパティ]ウィンドウの[コンディション]に、処理を実行する条件を設定できます。
count==5と入力します。
countが5の場合、繰り返し処理を強制終了します。
[ステートメント]アイコンを選択します。
[フローコントロールステートメント]から[BREAK]を選択します。
BREAKステートメントは、実行時点で、繰り返し処理を強制終了できます。
Breakを、IFのThenにドラッグします。
シミュレーションを実行します。
設定変更前と、同様の動作をすることがわかります。
シミュレーションをリセットします。
Partの生成を失敗する処理を追加します。
失敗した場合、Partは生成されず、countも増加しません。
失敗する条件を設定します。
[ステートメント]アイコンを選択します。
[フローコントロールステートメント]から[IF]を選択します。
IFをWorkの下にドラッグします。
疑似ランダム関数を使用し、失敗する確率を設定します。
疑似ランダム関数とは、実際には規則性があるが、規則性がないように見える数値を作成する関数です。
疑似ランダム関数についての詳細は、[ヘルプ]タブ-[ヘルプファイル]-[式]-[関数]-[疑似ランダム分布関数]で確認できます。
今回は、uniform関数を使用します。
uniform関数は、3つの引数を使用し、数値を作成できます。
[ステートメントプロパティ]ウィンドウの[コンディション]に、uniform(1,0,100)と入力します。
第一引数は、ランダムな数値を作成するためのストリーム引数です。
ストリーム引数の詳細は、動画「正規分布を使用して疑似乱数を作ってみよう」を参照してください。
第二引数は、ランダムな数値の最小値、第三引数は、最大値です。
初期値1を使用し、0以上、100未満の数値を作成できます。
<20と追記し、作成した数値が20未満であるかを評価します。
確率は、20％です。
失敗したことを、[出力]ウィンドウに表示します。
[ステートメント]アイコンを選択します。
[その他のステートメント]から[プリント]を選択します。
Printを、If uniformのThenにドラッグします。
[ステートメントプロパティ]ウィンドウの[メッセージ]にFaildと入力します。
Faildという文字を表示するため、ダブルクォーテーションマークが必要です。
Whileの先頭に戻り、条件を再評価します。
[ステートメント]アイコンを選択します。
[フローコントロールステートメント]から[CONTINUE]を選択します。
CONTINUEステートメントは、WHILEステートメントの先頭に戻り、条件を再評価できます。
WHILEステートメント内の残りのステートメントは、実行されません。
Continueを、Print:Faildの下にドラッグします。
Partの生成に失敗した場合、作業後、Whileの先頭に戻り、再度作業を実行します。
作業と作業の境目がわかるようにします。
[ステートメント]アイコンを選択します。
[その他のステートメント]から[ディレイ]を選択します。
ディレイステートメントは、次のステートメントの実行を、任意の時間、遅延させることができます。
Delayを、Workの上にドラッグします。
[ステートメントプロパティ]ウィンドウの[時間ソース]は、遅延時間の計算方法に、関数、または任意の計算式を使用できます。
分布を選択し、関数を使用します。
[分布]は、待機時間を定義できます。
[+]アイコンを選択します。
[Distribution]ウィンドウの[分布]で関数を指定できます。
使用できる関数は、[ヘルプ]タブ-[ヘルプファイル]-[式]-[関数]-[疑似ランダム分布関数]で確認できます。
今回、遅延時間には固定の数値を設定するため、[定数値]を選択します。
[値]を3に変更し、3秒の遅延を発生させます。
シミュレーションを実行します。
Partの生成に失敗した場合、作業後、搬送せず、3秒待機し、再度作業を実行しています。
[出力]ウィンドウには、Partを生成した回数と、Faildという文字が表示されたことがわかります。
シミュレーションをリセットします。
プロセスモデリングで、処理を繰り返す方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

製品ごとに輸送経路を変えてみよう

製品の種類ごとに分岐コンベア上の輸送経路を変更する方法
（フローグループ、プロセスフロー、RoutingRule、トランスポートソリューションルール）
https://youtu.be/ha1ApCq7hDQ
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_105.zip

本動画では、製品ごとに輸送経路を変える方法を説明します。製品ごとに輸送経路を変えるには、コンベアのルーティングルールを変更する必要があります。
まず初めに、製品ごとに輸送経路を変えてみよう.vcmx を開きます。
[プロセス]タブ-[エディタ]-[フロー]をクリックします。
[プロセスフローエディタ]ウィンドウ-"フロー(Can)"をクリックします。
"Feeder"のプロセスノード-"Sink(Can)"のプロセスノードと順にクリックして、"Feeder-Sink(Can)"のプロセスフローを生成します。
次に、[プロセスフローエディタ]ウィンドウ-"フロー(Bottle)"をクリックします。
"Feeder"のプロセスノード-"Sink(Bottle)"のプロセスノードの順でクリックして、"Feeder-Sink(Bottle)"のプロセスフローを生成します。
シミュレーションを再生します。
「Can」はまっすぐ、「Bottle」は上へ輸送されます。
流れてきた製品の輸送経路は、"RoutingRule"の設定で決まります。
「Conveyor Y-divert」をクリックします。
[コンポーネントプロパティ]ウィンドウの下の方にある"RoutingRule"を展開します。
"RoutingRule"画面の見方を説明します。
"ルート"は、現在設定しているルートを一覧で表示します。
"タイプ"は、ルート"で設定するルールを選択します。
"タイプ"下部には、ルール毎に設定するプロパティを表示しています。
初期設定の"環状"ルールについて説明します。
"環状"ルールは、設定した順番通りに輸送経路を決めるルールです。
今回の場合、製品の輸送経路は、まっすぐ-上-まっすぐ-上…と順番に決まります。
プロセスフローによって製品の輸送経路を決定するようにルーティングルールを変更します。
"タイプ"を"トランスポートソリューションルール"に変更し、"続行しますか?"で"はい"をクリックします。
"トランスポートソリューションルール"は、プロセスフローによって輸送経路を決めるルールです。
"ルール変数"は、プロセスフローのどの設定を、経路選択で使用するか定義します。
"次のトランスポートノードへ"の場合、次に設定されている"Transport Node"によって、輸送経路を決めます。
"ソースノード"の場合、製品がどのプロセスから生成されたかによって、輸送経路を決めます。
"目的地ノード"の場合、製品をどのプロセスへ輸送するかによって、輸送経路を決めます。
"ルール変数"を"目的地ノード"に変更します。
"接続もしくはルールを追加"を2回押下します。
"Can"の輸送経路を定義します。
"ルール変数"に"Sink Process (Can)…"を設定します。
"接続"は"Straight"にします。
"Bottle"の輸送経路を定義します。
"ルール変数"に"Sink Process (Bottle)…"を設定します。
"接続"は"Side"にします。
これで、プロセスフローで設定した目的地ノードによって、製品の輸送経路が決まるようになりました。
シミュレーションを再生します。
「Can」は目的地ノードが「Sink Process(Can)」なので真っすぐに、「Bottle」は目的地ノードが「Sink Process (Bottle)」なので上方向に輸送されます。
"ルール変数"を"次のトランスポートノード"に変更します。
トランスポートノードはプロセスフローの設定で定義されているため、先ほど同様に製品が輸送されます。
プロセスフローにプロセスを追加した場合の動作を確認します。
[ホーム]タブ-[マニピュレーション]-[PnP]をクリックします。
「Sink Process (Can)」と「Conveyor #3」を複数選択してドラッグし、「Conveyor Y-divert」から距離を離して接続を解除します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Flow Components]から"From Conveyor Process"と"To Conveyor Process"を3Dワールド上にドラッグ&ドロップします。
「From Conveyor Process」をドラッグして「Conveyor Y-divert」に近づけ接続します。
「To Conveyor Process」をドラッグして「Conveyor #3」に近づけ、接続します。
「From Conveyor Process」から「To Conveyor Process」へ製品を輸送するリソースを追加します。
[タイプ別モデル]-[PM Resources]から"Human"を3Dワールド上にドラッグ&ドロップします。
[タイプ別モデル]-[PM Transport Controllers]から"Human Transport Controller"を3Dワールド上にドラッグ&ドロップします。
[接続]-[インターフェース]をクリックし、「Human Transport Controller」の"Resources"と"Human"を接続します。
[プロセス]タブ-[エディタ]-[フロー]をクリックして、プロセスフローを修正します。
[プロセスフローエディタ]ウィンドウ-"フロー(Can)"をクリックします。
"Feeder-Sink(Can)"の間のひし形アイコンをクリックしてDeleteキーを押下し、トランスポートリンクを削除します。
[プロセスフローエディタ]ウィンドウ-"フロー(Can)"-"Feeder"を選択した状態で"Feeder"のプロセスノード-"FromConveyor"のプロセスラベルと順にクリックします。
「Human Transport Controller」のひし形アイコンをクリックして選択状態にし、"ToConveyor"のプロセスラベルをクリックします。
「Human Transport Controller」のひし形アイコンを再度クリックして選択状態を解除し、"Sink(Can)"のプロセスノードをクリックします。
フロー(Can)のプロセスフローを"Feeder-From Conveyor-To Conveyor-Sink(Can)"に修正できました。
追加したプロセスのステートメントの設定を修正します。
[エディタ]-[プロセス]をクリックして、「FromConveyor」をクリックします。
"TransportIn:~"をクリックします。
[ステートメントプロパティ]ウィンドウ-"ソース"を"前のプロセスから"に変更します。
「ToConveyor」をクリックします。
"TransportOut:~"をクリックします。
[ステートメントプロパティ]ウィンドウ-[目的地]を「次のプロセスへ」に変更します。
追加したプロセスのステートメントを修正できました。
シミュレーションを再生します。
「Can」が「Conveyor Y-divert」で停止します。
「Conveyor Y-divert」を選択してルーティングルールを確認します。
プロセスフローを変更したため、「Can」の次のトランスポートノードは「Sink Process(Can)」から「From Conveyor Process」に変わりました。
"ルール変数"が"From Conveyor Process"の場合の輸送経路を定義していないため、「Can」は"ルール変数"が"既定"の場合の輸送経路に決まります。
しかし、"ルール変数"が"既定"の場合の"接続"は"未定義(空欄)"だったため「Can」は「Conveyor Y-divert」で停止しました。
"ルール変数"を"Sink Process (Can)"から"From Conveyor Process"に変更します。
シミュレーションを再生します。先ほどと同じように製品が輸送されます。
次に、"ルール変数"を"ソースノード"に変更して、どのプロセスで生成されたかで輸送経路を決めるようにします。
まず、「Feeder Process」を追加して「Can」と「Bottle」を別々のプロセスで生成するようにします。
「Feeder Process」と「Conveyor」を複数選択してドラッグし、「Conveyor Y-divert」から距離を離して接続を解除します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Conveyors]-[Visual Components]から"Crossing Conveyor"を3Dワールド上にドラッグ&ドロップします。
[マニピュレーション]-[PnP]を選択した状態で「Crossing Conveyor」をドラッグし、「Conveyor Y-divert」に近づけ、接続します。
「Feeder Process」と「Conveyor」を複数選択してドラッグし、「Crossing Conveyor」に近づけ、接続します。
「Feeder Process」と「Conveyor」を複数選択した状態でコピー&ペーストし、生成したコピーをドラッグして「Crossing Conveyor」に近づけ、接続します。
「CrossingConveyor」をクリックします。
"RoutingRule"を「Conveyor Y-divert」の方向へ常に輸送するように変更します。
「Feeder Process」をクリックします。
[コンポーネントプロパティ]ウィンドウ-[ProductCreator]タブから"フィードモード"を"単一"、"間隔"を"10"、"パーツ"を"Can"に変更します。
[既定]タブをクリックして[名前]を"Feeder Process(Can)"に変更します。
「Feeder Process #2」をクリックします。
[コンポーネントプロパティ]ウィンドウ-[ProductCreator]タブから、"フィードモード"を"単一"、"間隔"を"10"、"パーツ"を"Bottle"に変更します。
[既定]タブをクリックして、[名前]を"Feeder Process(Bottle)"に変更します。
これで、「Can」と「Bottle」を別々のプロセスで生成するようにできました。
次に、「Conveyor Y-divert」を選択して、ルーティングルールを変更します。
"トランスポートソリューションルール"-"ルール変数"を"ソースノード"に変更します。
"接続"が"Straight"の"ルール変数"を"Feeder Process(Can)"、"接続"が"Side"の"ルール変数"を"Feeder Process(Bottle)"に変更します。
これで、ルーティングルールを変更できました。
最後に、プロセスフローを作成します。
[プロセス]タブ-[エディタ]-[プロセス]をクリックします。
「Feeder Process(Can)」の「Feeder」をクリックします。名前を「Feeder(Can)」に変更します。
「Feeder Process(Bottle)」の「Feeder」をクリックします。名前を「Feeder(Bottle)」に変更します。
[プロセス]タブ-[エディタ]-[フロー]をクリックします。
[プロセスフローエディタ]ウィンドウ-"フロー(Can)"をクリックします。
"Feeder(Can)-Sink(Can)"のプロセスフローを設定します。
[プロセスフローエディタ]ウィンドウ-"フロー(Bottle)"をクリックします。
"Feeder(Bottle)-Sink(Bottle)"のプロセスフローを設定します。
これで、プロセスフローが設定できました。
シミュレーションを再生します。
「Can」は「Feeder Process (Can)」で生成されたため真っすぐに、「Bottle」「Feeder Process (Bottle)」で生成されたため上へ輸送されます。
以上で、「製品ごとに輸送経路を変えてみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

製品のフローを定義してみよう

Gemini 1.45以降の機能です。
ラインシミュレーション上の製品の流れ（フロー）を設定する方法（プロセスフローエディタ、フローステップ、トランスポートリンク、IsOptional、ProcessMode、フローステップを取得、次のフローステップを設定）
https://youtu.be/TKb5kSsnYtU
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_138.zip

本動画では、フローの設定を通して、プロセスフローエディタの使い方や、フローに関係するステートメントの使い方を説明します。
はじめに、「製品のフローを定義してみよう.vcmx」を開きます。
このレイアウトにフローを設定します。
[プロセス]タブ-[エディタ]-[フロー]をクリックして、[プロセスフローエディタ]を表示します。
フローを設定するには、[プロセスフローエディタ]にプロセスを追加する必要があります。
追加する方法は、①3Dワールド上のプロセスラベルをクリックする方法、②3Dワールド上のプロセスラベルをフローステップまでドラッグしてドロップする方法、③プロセスフローエディタ右のプラスアイコンをクリックして追加する方法、の3種類あります。
選択中のプロセスは、丸の色が水色から黄色になります。黄色の状態で、別のプロセスを選択すると、フローが設定できます。
プロセスラベルをクリックした場合、同名のプロセスを複数選択した状態になります。
"Feeder"-"ManualProcess"-"Parametric Lathe"-"Sink"のフローを設定します。
これで、フローを設定できました。
シミュレーションを再生します。
製品が、"Feeder"-"ManualProcess"-"Parametric Lathe"-"Sink"へ流れます。
次に、プロセスフローエディタ内の操作について説明します。
プロセスフローエディタ内のプロセスをドラッグすると、プロセスの位置を変更することができます。
プロセスフローエディタ内でプロセスをドラッグしたり、プロセスを削除したりすると、元々プロセスがあった場所が空フローステップになります。
フローを実行した時に空フローステップに到達した場合、次のプロセスが特定できないため、フローが途中で止まってしまいます。
フローを設定する時は、空フローステップを作らないようにしてください。
プロセスフローには、1つのステップに複数のプロセスを設定することができます。
例として、"Parametric Lathe"の名前を変更して、複数のプロセスを設定します。
"Parametric Lathe"の名前を"Parametric Lathe 2"、"Parametric Lathe 3"に変更します。
この状態で、一度シミュレーションを再生します。
"Parametric Lathe 2"と"Parametric Lathe 3"はプロセスフローに追加していないので、製品が流れません。
プロセスフローエディタの"Parametric Lathe"の下に"Parametric Lathe 2"と"Parametric Lathe 3"を追加します。
再度シミュレーションを再生します。
"Parametric Lathe 2"と"Parametric Lathe 3"にも製品が流れるようになります。
複数のプロセスを設定したステップは、上部のハンドルを選択してドラッグすることで、まとめて移動させることができます。
ハンドルのプロパティについて説明します。
最初に、"ProcessMode"について説明します。
"ProcessMode"は、複数のプロセスを設定したステップの設定で、どのプロセスを実行するかの設定です。
"最初に利用可能なプロセス"の場合、プロセスフローに並んだ順に利用可能か確認し、利用可能なプロセスから実行します。
プロセスフローエディタ上での順番を"Parametric Lathe 3"、"Parametric Lathe 2"、"Parametric Lathe"に変更します。
シミュレーションを再生します。
製品が流れる時、"Parametric Lathe 3"-"Parametric Lathe 2"-"Parametric Lathe"の順で流れるようになります。
複数のプロセスが利用可能である場合、[プロセスフローエディタ]上で上にあるプロセスを優先して実行します。
"Parametric Lathe"を複数選択します。
[コンポーネントプロパティ]ウィンドウ-[既定]タブから"ProcessTime"を"1"に変更します。
シミュレーションを再生します。
"Parametric Lathe 3"か"Parametric Lathe 2"のいずれかが常に利用可能になっているので、"Parametric Lathe"には製品が流れなくなります。
"任意の順序で全てのプロセス"は、ステップ内のすべてのプロセスを実行します。
"ProcessMode"を"任意の順序で全てのプロセス"に変更します。
[プロセスフローエディタ]上のプロセスラベルのアイコンの形が変化します。
今回の場合、"Parametric Lathe 3"、"Parametric Lathe 2"、"Parametric Lathe"が任意の順番で実行されます。
動作を確認するために、設定を変更します。
"Parametric Lathe 3"、"Parametric Lathe 2"、"Parametric Lathe"を全て通るように、トランスポートリンクを追加します。
この時、プロセスフローの追加の設定は不要です。
シミュレーションを再生します。
"Sink"へ移動する前に、3つの"Parametric Lathe"を通過するようになりました。
"ProcessMode"を"最初に利用可能なプロセス"に戻します。
"Parametric Lathe"同士のトランスポートリンクを削除します。
「Parametric Lathe」を複数選択して、"ProcessTime"を"60"に戻します。
"ProcessMode"の説明は以上になります。
次に、"IsOptional"について説明します。
"IsOptional"は、次のプロセスが利用できない場合に、別のステップのプロセスを実行するようにする機能です。
"IsOptional"を使って、「"ManualProcess"から"Parametric Lathe"へ移動する時に、"Parametric Lathe"が利用できない場合は"Buffer"で待機する」ようにします。
一度、レイアウトを修正します。
[eカタログ]ウィンドウ-[タイプ別モデル]-"PM Warehousing"から"Warehouse Shelf"を3Dワールドに配置します。
"Feeder"-"ManualProcess"-"Buffer"-"Parametric Lathe"、または"Parametric Lathe2"、または"Parametric Lathe3"-"Sink"となるようにトランスポートリンクを追加します。
この時、"ManualProcess"-"ParametricLathe"間のトランスポートリンクは削除しないでください。
シミュレーションを再生します。
"Feeder"-"ManualProcess"-"Buffer"-"Parametric Lathe"、または"Parametric Lathe 2"、または"Parametric Lathe 3"-"Sink"という順で製品が流れます。
現在の設定では、"Parametric Lathe"に空きがある場合でも、一度"Buffer"を経由して、製品が流れています。
設定を変更します。
"Buffer"のハンドルをクリックします。
[プロパティ]ウィンドウから"IsOptional"を有効にします。
プロセスフローエディタ上の"Buffer"と"Buffer"-"Parametric Lathe"間のトランスポートリンクの枠線が黄色に変わり、"Buffer"の前にトランスポートリンクが追加されました。
これで、プロセスの利用状況で、実行するプロセスが切り替わるようになります。
"Parametric Lathe"のいずれかが利用可能の場合、"ManualProcess"-"Parametric Lathe"の順で製品が流れます。
この時、枠線が黄色のプロセスはスキップされます。
"Parametric Lathe"が利用不可の場合、"ManualProcess"-"Buffer"-"Parametric Lathe"の順で製品が流れます。
"Parametric Lathe"が利用可能になるまで、製品は"Buffer"で待機します。
この時、枠線が黄色のプロセスが実行されます。
"ManualProcess"-"Parametric Lathe"間のトランスポートリンクを残したのは、"IsOptional"を有効にした時に、"Parametric Lathe"が利用可能の場合のトランスポートリンクで使用するからです。
シミュレーションを再生します。最初の方は"Parametric Lathe"が利用可能であるため、"ManualProcess"-"Parametric Lathe"と製品が流れます。
"Parametric Lathe"がどれも使用中の場合、"Buffer"へ移動して"Parametric Lathe"が利用可能になるまで待機します。
"IsOptional"を使うことで、同じフローステップで同名・同一のプロセスを複数回使用することができます。
「ManualProcessへ製品を流す前に、Bufferを経由する」ように、設定を追加します。
"Feeder"-"ManualProcess"を"Feeder"-"Buffer"-"ManualProcess"になるようにトランスポートリンクを追加します。
動作を確認しやすくするために、製品の生成方法をバッチ生産にします。
「Feeder Process」をクリックします。
[コンポーネントプロパティ]ウィンドウ-[ProductCreator]タブから、"フィードモード"を"バッチ"に変更します。
"バッチ間隔"を"720"、"Product"を"Cube"、"Count"を"25"に変更します。
シミュレーションを再生します。問題なく製品が流れます。
"IsOptional"の説明は以上になります。
フローに、「"ManualProcess"で一定の確率で不良品が生成されるようにし、不良品の場合は"Buffer"や"Parametric Lathe"を介さず、直接"Sink"へ流す」設定を追加します。
設定方法の1つに、不良品専用のフローグループを追加して、処理を切り替える方法がありますが、今回は使用しません。
プロセスフローシーケンスステートメントを使って、1つのフローグループ内で切り替えるように設定を行います。
前準備として、"Sink"のハンドルをクリックします。
[プロパティ]ウィンドウから[名前]を"Defects and Sink"に変更します。
次に、"ManualProcess"に設定を追加します。
[プロセス]タブ-[エディタ]-[フロー]を選択した状態で、左側の"ManualProcess"のプロセスラベルを右クリックします。
"State:Blocked"を選択した状態で、ステートメントから"IF"ステートメントを追加します。
追加した"IF"ステートメントをクリックし、[ステートメントプロパティ]ウィンドウから[コンディション]を"uniform(0,0,100) < 10"と設定します。
これは、「IF文を実行するたびに、0以上100未満の数値をランダムで生成し、その値が10未満だった場合Thenの処理、10以上だった場合はelseの処理を行う」条件式になります。
"Then"に不良品を生成して、"Sink"へ直接移動する処理を記述します。
"Then"の下の"<empty>"をクリックします。
ステートメントから"ノードマテリアルを設定"を追加します。
このステートメントは、初期設定では「製品変数名が"ProductIn"の[マテリアル]を"red"に変更する」ので、そのまま使用します。
これで、「10%で不良品になり、不良品になった場合は赤色になる」ようになりました。
次に、ステートメントから"フローステップを取得"を追加します。
このステートメントは、フローステップの情報を変数に保存するステートメントです。
"FlowStepSource"は、取得する情報を設定します。
今回は、"フローステップ"を設定します。
"ReturnVariableName"は、取得した情報を保存する変数の名前の設定です。
今回は、デフォルトの"FlowInfo"を使用します。
"FlowGroup"は、どのフローグループから情報を取得するかの設定です。
今回は、"フローグループ番号1"を設定します。
"FlowStep"は、"FlowGroup"のどのフローステップの情報を取得するかをリストボックスで設定します。
今回は、"[5]Defects and Sink"を設定します。
これで、「フローグループ番号1のSinkのフローステップの情報を取得して、FlowInfoに保存する」ことができました。
次に、ステートメントから"次のフローステップを設定"を追加します。
このステートメントは、「ProductInの移動先の情報をFlowInfoに書き換える」ことができます。
今回は、各設定がデフォルトのまま使用します。
これで、「10%の確率で不良品が生成され、不良品の場合は直接Sinkへ移動する。」処理が設定できました。
残りの"ManualProcess"にも設定を行います。
"IF"をコピーして、もう一つの"ManualProcess"の"State:Blocked"の下にペーストします。
"GetFlowStep:~"を選択して、[ステートメントプロパティ]ウィンドウから"FlowStepSource"を"製品の現在のプロセス"に変更します。
"GetFlowStep:~"を選択した状態で"ステートメント"から"フローステップを見つける"を追加します。
このステートメントは、既存のフローステップの前後のフローステップを探すステートメントです。
"ProcessToFind"を"Sink"に変更します。
2つの"ManualProcess"で処理が異なりますが、どちらも「10%で赤色の不良品が生成され、その場合は直接"Sink"へ流す」ようになりました。
最後に、"ManualProcess"-"Sink"間のトランスポートリンクを追加します。
これで、不良品の設定が追加できました。
シミュレーションを再生します。
一定の確率で、"ManualProcess"で不良品が生成され、生成された不良品は直接"Sink"へ流れるようになりました。
以上で、「製品のフローを定義してみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

製品の情報ごとに実行する処理を変更しよう

製品の情報を取得し、実行する処理を変更する（IFステートメント、SWITCH CASEステートメント、ProductType）
https://youtu.be/53sP_7zCvOo
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_173.zip

製品の情報ごとに実行する処理を変更する方法について説明します。
事前ファイル「Branch_before.vcmx」を開きます。
シミュレーションを実行します。
Feederから、ライトグリーンのシリンダー、ライトピンクのピラミッド、ライトシアンのブロックが生成されます。
シミュレーションをリセットします。
生成する製品は、Feederの[コンポーネントプロパティ]ウィンドウ-[ProductCreator]タブで確認できます。
製品の情報を確認するため、[プロセス]タブ-[エディタ]グループの[製品]を選択します。
プロセスモデリングでは、[製品タイプエディタ]ウィンドウの製品タイプに、生成する製品の情報を定義できます。
[製品タイプのプロパティ]ウィンドウで、製品タイプごとの見た目を設定しています。
最初に、2パターンの処理を設定する方法について説明します。
製品タイプごとに色を変更します。
製品タイプがブロックの場合、赤、ブロックではない場合、青です。
コンベア上に処理を実行する場所を設定します。
[eカタログ]-[タイプ別モデル]-[PM Flow Components]を選択します。
Process Nodeを、ダブルクリック、または3Dワールドにドラッグ＆ドロップすることで、モデルを配置できます。
ダブルクリックの場合、3Dワールドの原点に配置されます。
ドラッグ＆ドロップの場合、マウスボタンをはなした位置に配置されます。
[マニピュレーション]グループの[PnP]を選択していることを確認し、Process Nodeをコンベアの中央にドラッグします。
Process Nodeに表示されている三角形が、黄色から、黄緑に変化した場合、コンベアと接続されています。
[エディタ]グループの[プロセス]を選択し、実行する処理を設定します。
[Process#1]を選択します。
TransportInは、コンベアからProcess#1に搬入、TransportOutは、Process#1からコンベアに搬出できます。
しかし、シミュレーションを実行して確認すると、製品がProcess#1に搬入されていないことがわかります。
TransportInを選択します。
[ステートメントプロパティ]ウィンドウの[ソース]は、搬入元からの搬送方法を指定できます。
[前のプロセスから]となっていますが、Process#1に前のプロセスはありません。
Feederから生成された製品は、コンベアのパスに格納されることで、コンベア上を移動しています。
パスとは、コンポーネントを格納し、指定した経路上を移動させることができる動作設定です。
パスは、コンテナタイプであるため、[ソース]を[コンポーネントコンテナから]に変更します。
搬入した製品には、[製品変数名]で指定した名前が付与されます。
Process#1でのみ使用可能な名前です。
今回は、デフォルトのProductInを使用します。
同様に、TransportOutの搬出先をコンベアのパスに指定する必要があります。
TransportOutを選択し、[ステートメントプロパティ]ウィンドウの[目的地]を[コンポーネントコンテナへ]に変更します。
シミュレーションを実行して確認すると、製品がProcess#1に搬入されていることがわかります。
新規ステートメントを追加するため、[ステートメント]アイコンを選択します。
[フローコントロールステートメント]から[IF]を選択します。
IFステートメントは、条件を満たしている場合と、満たしていない場合の、2パターン処理を設定できます。
条件を満たしている場合の処理はThen、満たしていない場合の処理はElseに設定します。
[ステートメントプロパティ]ウィンドウの[コンディション]に条件を入力できます。
条件には、製品タイプ名を入力します。
搬入された製品のタイプを取得する場合、[コンディション]にProductIn.ProductTypeと入力します。
[.Name]と追記することで、製品タイプ名を取得できます。
製品の情報を取得する方法は、[ヘルプファイル]、[プロセスモデリング]の[プロセスステートメント式]で確認できます。
今回は、製品タイプ変数の構文の2行目を使用し、ProductTypeのNameを取得しています。
1行目は、製品タイプの製品プロパティ、3行目は、コンポーネントプロパティ、4行目は、製品タイプが所属するフローグループのプロパティを取得できます。
製品タイプ名が、Blockであるか判断するため、[=="Block"]と追記します。
製品タイプ名は、文字列であるため、ダブルクォーテーションマークではさみます。
ブロックの色を赤に変更します。
[ステートメント]アイコンを選択します。
[その他のステートメント]から[ノードマテリアルを設定]を選択します。
デフォルトでは、ProductInの色を赤に変更します。
SetNodeMaterialを選択し、Thenにドラッグ＆ドロップします。
ブロックではない製品を青に変更するため、SetNodeMaterialを選択した状態で、コントロールキーとCを押し、コピーします。
Elseを選択し、コントロールキーとVを押し、貼り付けます。
色を青に変更するため、[ステートメントプロパティ]ウィンドウの[マテリアル]をblueに変更します。
IfをTransportInとTransportOutの間に、ドラッグします。
シミュレーションを実行して動作を確認します。
ブロックではない製品は青、ブロックは赤に変更していることがわかります。
シミュレーションをリセットします。
次に、処理を3パターン以上設定する方法について説明します。
Ifを実行しないようにします。
Ifを選択し、右クリックします。
[有効/無効切り換え]を選択することで、ステートメントの有効/無効を切り換えることができます。
[ステートメント]アイコンを選択します。
[フローコントロールステートメント]から[SWITCH CASE]を選択します。
SWITCH CASEステートメントは、条件式の値と一致した場合の、処理を実行します。
[ステートメントプロパティ]ウィンドウの[コンディション]に、ProductIn.ProductType.Nameと記述します。
Switchにカーソルを合わせることで表示される[＋]アイコンを選択し、パターンを増やすことができます。
Case <empty>を選択します。
[プロパティ]ウィンドウの[ケースコンディション]に値を入力します。
"Block"と入力します。
条件式ProductIn.ProductType.Nameの値が、"Block"と一致した場合、処理を実行できます。
同様に、製品タイプ名が、Cylinderの場合を追加します。
[ケースコンディション]に、defaultと入力することで、条件式の値が、想定外の場合を設定することもできます。
defaultは、大文字、小文字どちらで入力しても構いません。
製品の色を、Blockの場合、赤、Cylinderの場合、青、その他の場合、緑に変更します。
SetNodeMaterialを選択し、コピーします。
Case "Block"を選択し、貼り付けます。
同様に、Cylinderの場合と、その他の場合を選択し、貼り付けます。
設定する[マテリアル]は、上からred、blue、greenです。
シミュレーションを実行して動作を確認します。
設定した処理通りに動作していることがわかります。
シミュレーションをリセットします。
製品の情報ごとに実行する処理を変更する方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

輸送と作業の優先度について学ぼう

輸送タスクや作業タスクに対して優先度を設定する方法（Priority）
https://youtu.be/rTk-YmwBGhc
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_114.zip

本動画では、輸送タスクや作業タスクに対して優先度を設定する方法について説明します。
初めに、「輸送と作業の優先度について学ぼう.vcmx」を開きます。
シミュレーションを再生します。
"Feeder1"で生成された製品が"Sink1"、"Feeder2"で生成された製品が"Sink2"、"Feeder3"で生成された製品が"Sink3"と順に輸送されます。
このレイアウトの輸送タスクと作業タスクに、優先度を設定します。
輸送タスクと作業タスクでは、"Priority"プロパティを設定することで、各タスクに優先度を設定できます。
まず、輸送タスクの優先度を設定します。
輸送タスクの[Priority]は、トランスポートリンクの[プロパティ]ウィンドウで設定できます。
[プロセス]タブ-[エディタ]-[フロー]をクリックします。
[プロセスフローエディタ]ウィンドウ-"Flow Group #1"をクリックします。
"Feeder1"-"Sink1"フロー間のひし形アイコンをクリックし、[プロパティ]ウィンドウを表示します。
[Priority]は、優先度を設定するプロパティです。
"1"から"100"までの数値が設定でき、数値が小さいほど優先度は高くなります。
[Priority]が同値のタスクが複数ある場合は、FIFO(先入れ先出し)の原則にのっとり処理されます。
[Priority]を"2"に変更します。
[プロセスフローエディタ]ウィンドウ-"Flow Group #2"をクリックします。
"Feeder2-Sink2"フロー間のひし形アイコンをクリックします。
[プロパティ]ウィンドウから[Priority]を"3"に変更します。
[プロセスフローエディタ]ウィンドウ-"Flow Group #3"をクリックします。
"Feeder3-Sink3"フロー間のひし形アイコンをクリックします。
[プロパティ]ウィンドウから[Priority]を"4"に変更します。
これで、輸送タスクの優先度を設定できました。
シミュレーションを再生します。
輸送タスクを行う際に、[Priority]が小さい輸送タスクを優先して行うようになります。
次に、プロセスに"作業"ステートメントを追加して、作業タスクの優先度を設定します。
[プロセス]タブ-[エディタ]-[プロセス]をクリックします。
"Sink1"をクリックします。
"Delay:10s"を選択した状態で"ステートメント"の"作業"と"Delay"を追加します。
追加された"Work:~"をクリックします。
[ステートメントプロパティ]ウィンドウから"コントローラ"を"Human Transport Controller"に変更します。
作業タスクの優先度を設定します。
作業タスクの[Priority]は、コントローラの[Work]タブで設定できます。
「Human Transport Controller」をクリックします。
[コンポーネントプロパティ]ウィンドウ-[Work]タブをクリックします。
[Priority]を"1"に設定します。
"Priority"は、輸送タスクと作業タスクの設定を共有して使用されます。
シミュレーションを再生します。
"Sink1"の作業タスクを最優先で実行し、実行していない間に他のプロセスを実行するようになります。
[Priority]の値が同じ輸送タスクと作業タスクが同時に存在する場合、先に待機していたタスクを優先して行います。
そのため、[Priority]の値が同じ"Feeder3-Sink3"フロー間の輸送タスクと、"Sink1"の作業タスクでは、先に待機していた"Feeder3-Sink3"フロー間の輸送タスクが優先して実行されます。
以上で、「輸送と作業の優先度について学ぼう」を終わります。
ご視聴ありがとうございました。

=================================================================================

製品の積み降ろしを他の作業者などにさせよう

製品の積み降ろしを他の作業者などにさせる方法
例：AGVへの製品の積み降ろしを、作業者が行う
https://youtu.be/Gaj25LKE03I
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_047.zip

本動画では、AGVなどの輸送を行うリソースに製品を積む、または降ろす時に、他の作業者などに製品の積み降ろし作業を割り当てる方法について説明します。
「製品の積み降ろしを他の作業者などにさせよう.vcmx」を開きます。
まず、製品を輸送するプロセスフローを作成します。
[プロセス]タブ-[エディタ]-[フロー]をクリックします。
"Feeder"のプロセスラベル-"Mobile Robot Transport Controller"上のひし形アイコン-"Sink"のプロセスラベルと順にクリックします。
プロセスフローを作成できました。
シミュレーションを再生します。
「Mobile Robot Resource」が製品を輸送します。
「Mobile Robot Resource」へ製品を積む、または製品を降ろす時、製品が自動的に移動しています。
この時の製品の移動を、他の作業者などに移動させるように設定を変更します。
製品の積み降ろしの設定は、プロセスフローのトランスポートリンクから変更ができます。
"Feeder-Sink"フローのひし形アイコンをクリックして[プロパティ]ウィンドウを開きます。
製品の積み降ろしに関するプロパティについて説明します。
"LoadAssist"は、輸送作業を行うリソースへ製品を積む作業を行うリソースの設定です。
"UnloadAssist"は、輸送作業を行うリソースから製品を降ろす作業を行うリソースの設定です。
"LoadAssist"を変更して、「Feeder Process」で「Mobile Robot Resource」へ製品を積む時に、「Human」が製品を積む作業を行うように設定します。
設定する値は、積み降ろし作業を割り当てたいリソースを制御するコントローラを設定します。
今回の場合、「Human」を制御する「Human Transport Controller」を設定します。
シミュレーションを再生します。
「Mobile Robot Resource」が「Feeder Process」で製品を積む時、「Human」が製品を積む作業を行うようになりました。
「Human」の作業位置と、製品を積む時の「Mobile Robot Resource」の待機位置が被っているため、位置を変更して被らないようにします。
製品を積む時の「Mobile Robot Resource」の待機位置を変更します。
"プロパティ"ステートメントから、"UseCustomParameters"にチェックを入れます。
プロパティの設定ができるようになるため、"ResourcePickOffset"の"X"を"-750"に設定します。
"ResourcePickOffset"は、製品を積む時のリソースの待機位置のオフセットを設定します。
シミュレーションを再生します。
製品を積む時の「Mobile Robot Resource」の待機位置を変更したため、「Human」と「Mobile Robot Resource」が重ならなくなります。
製品の積み降ろしを行うリソースの作業位置を変更する場合は、積み降ろし作業を行うコンポーネントに"AssistLocation"という名称のフレームを追加する必要があります。
「Feeder Process」にフレームを追加して、「Human」の作業位置を変更します。
[モデリング]タブをクリックします。
「Feeder Process」を選択した状態で[ジオメトリ]-[フィーチャ]-[フレーム]をクリックして、「Feeder Process」にフレームを追加します。
追加された「フレーム」をクリックし、"フィーチャ"プロパティから[名前]を"AssistLocation"に変更します。3Dワールドツールバーの"フレームタイプ"を有効にし、"フレーム"にチェックを入れます。
[マニピュレーション]-[移動]を選択した状態で、「AssistLocation」を任意の位置へ移動させ、向きを変更します。
シミュレーションを再生します。
「Human」が製品を運ぶとき、"AssistLocation"上で製品を受け取り、そのあと「Mobile Robot Resource」へ製品を運ぶようになりました。
「Mobile Robot Resource」の上にロボットを配置して、そのロボットが製品の積み降ろしを行うようにすることができます。
今回は、「UR5」を「Mobile Robot Resource」の上に配置して、製品の積み降ろしを行うようにします。
[ホーム]タブをクリックします。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Robots]-[Universal Robots]から、"UR"5を3Dワールド上にドラッグ&ドロップします。
[タイプ別モデル]-[PM Transport Controllers]から、「Robot Transport Controller」を3Dワールド上にドラッグ&ドロップします。
「Robot Transport Controller」をクリックし、「UR5」と大きさを合わせます。
[コンポーネントプロパティ]ウィンドウから"PedestalDiameter"を"150"、"PedestalHeight"を"100"に変更します。
[マニピュレーション]-[PnP]をクリックし、「UR5」を「Robot Transport Controller」に近づけ接続します。
「Robot Transport Controller」を選択して[ツール]-[スナップ]をクリックし、「Mobile Robot Resource」上に配置します。
「Robot Transport Controller」を選択した状態で[階層]-[アタッチ]をクリックし、「Mobile Robot Resource」をクリックして、アタッチします。
[プロセス]タブ-[エディタ]-[フロー]をクリックします。
"Feeder-Sink"フローのひし形アイコンをクリックして[プロパティ]ウィンドウを開きます。
"LoadAssist"と"UnloadAssist"をそれぞれ「Robot Transport Controller」に変更します。
このままでは、「UR5」が製品に届かないため、"ResourcePickOffset"を"0"に変更します。
シミュレーションを再生します。
「Mobile Robot Resource」が製品を輸送する時、「UR5」が製品の積み降ろし作業を行います。
一度に輸送する製品の数を変更します。
今回は、2個に変更します。
まず、「Mobile Robot Resource」の設定を変更します。
「Mobile Robot Resource」をクリックします。
[コンポーネントプロパティ]ウィンドウ-[Transport]タブから"Capacity"を"2"に変更します。
次に、輸送先のプロセスを変更します。
[プロセス]タブ-[エディタ]-[プロセス]をクリックし、"Sink"をクリックします。
"TranportIn:~"を選択した状態で、"ステートメント"-"トランスポートイン開始"を2回、"トランスポート待機"を1回クリックします。
"TransportIn:~"を削除します。
これで、製品を2個同時に輸送するようになります。
シミュレーションを再生します。
「Mobile Robot Resource」が製品を2個ずつ輸送します。
以上で、「製品の積み降ろしを他の作業者などにさせよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

製品の輸送元と輸送先の設定を知ろう

製品を輸送する設定で使用する、リソース（人やロボット）の考え方やプロパティの説明
https://youtu.be/fPitz8InIP4
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_083.zip

本動画では、シミュレーション中にプロセス間で製品を輸送するための設定について説明します。
プロセス間で製品を輸送するには、"トランスポートイン"ステートメントの"ソース"と"トランスポートアウト"ステートメントの[目的地]を正しく設定する必要があります。
初めに、コンポーネントを配置してレイアウトを構築します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Conveyors]から"Conveyor"を3Dワールド上にドラッグ&ドロップし、2つ配置します。
[タイプ別モデル]-[PM Flow Components]から"Feeder Process"、"FromConveyor Process"、"Transport Node"、"Sink Process"を3Dワールド上にドラッグ&ドロップします。
[タイプ別モデル]-[PM Transport Controller]から「Robot Transport Controller」を3Dワールド上にドラッグ&ドロップします。
[タイプ別モデル]を選択した状態で"検索"に"Generic"を入力し、[Machines]から「Parametric Lathe」、[Robots]から「Generic Articulated Robot」、[Robot Tools]から「Generic 3-Jaw Gripper」を3Dワールド上にドラッグ&ドロップします。
[マニピュレーション]-[PnP]を選択した状態で、「Conveyor」の左側に「Feeder Process」、右側に「From Conveyor Process」を近づけ、接続します。
「Conveyor #2」の左側に「Transport Node」、右側に「Sink Process」を近づけ、接続します。
「Generic Articulated Robot」を「Robot Transport Controller」の上に近づけ、接続します。
「Generic 3-Jaw Gripper」を「Generic Articulated Robot」のアームの先端に近づけ、接続します。
コンポーネントの位置を調整します。
これで、レイアウトを構築できました。
プロセスフローを作成します。
[プロセス]タブ-[エディタ]-[フロー]をクリックします。
"Feeder"のプロセスラベル-"FromConveyor"のプロセスラベル-"Parametric Lathe"のプロセスラベル-「TransportNode」上の白い丸-"Sink"のプロセスラベルと順にクリックします。
「Robot Transport Controller」上のひし形アイコンをクリックします。
"FromConveyor"-"Parametric Lathe"間のひし形アイコンを右クリックし、"トランスポートコントローラを変更"をクリックします。
"Parametric Lathe"-"TransportNode"間のひし形アイコンを右クリックし、"トランスポートコントローラを変更"をクリックします。
これで、プロセスフローを作成できました。
シミュレーションを再生します。製品が輸送されません。
原因について説明します。
[エディタ]-[プロセス]をクリックし、"Feeder"と"FromConveyor"を右クリックします。
"Feeder"の"TransportOut:~"と"FromConveyor"の"TransportIn:~"を選択し、[ステートメントプロパティ]ウィンドウからプロパティを確認します。
製品を輸送する場合、輸送元の"TransportOut:~"の[目的地]と輸送先の"TransportIn:~"の"ソース"は一致させる必要があります。
不一致の場合、製品の輸送がされません。
今回の場合、"Feeder"の"TransportOut:~"の[目的地]が「次のプロセスへ」、"FromConveyor"の"TransportIn:~"の"ソース"が"コンポーネントコンテナから"となっており、不一致なため製品が輸送されませんでした。
接続元と接続先の設定を一致させたときの動作について説明します。
輸送元の"トランスポートアウト"ステートメントの[目的地]が「次のプロセスへ」、輸送先の"トランスポートイン"ステートメントの"ソース"が"前のプロセスから"の場合について説明します。
輸送元の"トランスポートアウト"ステートメントの[目的地]が「次のプロセスへ」の場合、プロセスフローで接続しているプロセスへ製品を輸送します。
この時、輸送先の"トランスポートイン"ステートメントが実行中であり、かつ"ソース"が"前のプロセスから"である必要があります。
設定を変更して、動作を確認します。
"FromConveyor"をクリックします。
"TransportIn:~"を選択し、[ステートメントプロパティ]ウィンドウから"ソース"を"前のプロセスから"に変更します。
シミュレーションを再生します。
製品が輸送されます。
輸送元の"トランスポートアウト"ステートメントの[目的地]が「次のプロセスへ」、輸送先の"トランスポートイン"ステートメントの"ソース"が"前のプロセスから"の場合、輸送先が再び"トランスポート出力"ステートメントを実行するまで、輸送元は待機します。
今回の場合、"FromConveyor"が"TransportOut:~"を実行して再度"TransportIn:~"を実行するまで、"Feeder"は"TransportOut"を実行して待機します。
動作を確認します。
「Feeder Process」をクリックします。
[コンポーネントプロパティ]ウィンドウ-[ProductCreator]タブから"間隔"を"1"に変更します。
シミュレーションを再生します。
製品を生成する間隔を変更しましたが、"FromConveyor"が製品を"Parametric Lathe"へ輸送するまで、次の製品は"FromConveyor"へ輸送されません。
輸送元の"トランスポートアウト"ステートメントの[目的地]が「次のプロセスへ」、輸送先の"トランスポートイン"ステートメントの"ソース"が"前のプロセスから"の場合についての説明は以上になります。
輸送元の"トランスポートアウト"ステートメントの[目的地]が"コンポーネントコンテナへ"、輸送先の"トランスポートイン"ステートメントの"ソース"が"コンポーネントコンテナから"の場合について説明します。
コンポーネントコンテナとは、コンベアで輸送する製品を保持するビヘイビアです。
輸送元の"トランスポートアウト"ステートメントの[目的地]が"コンポーネントコンテナへ"の場合、製品は接続しているコンベアのコンポーネントコンテナへ輸送されます。
輸送先の"トランスポートイン"ステートメントの"ソース"が"コンポーネントコンテナから"の場合、輸送先のコンポーネントのコンポーネントコンテナが保持している製品を取り出して、使用します。
コンポーネントコンテナが製品を保持していない場合、コンポーネントコンテナが製品を保持するまで待機します。また、製品が取り出されコンポーネントコンテナに空きができると、すぐに次の製品を保持できます。
設定を変更して、動作を確認します。
"Feeder"をクリックします。
[ステートメントプロパティ]ウィンドウから[目的地]を"コンポーネントコンテナへ"に変更します。
"FromConveyor"をクリックします。
[ステートメントプロパティ]ウィンドウから"ソース"を"コンポーネントコンテナから"に変更します。
シミュレーションを再生します。先ほどと異なり、"Feeder"が生成した製品は"FromConveyor"の状況にかかわらず輸送されます。
また、製品が取り出され、コンポーネントコンテナに空きができたら、"FromConveyor"がステートメントを実行している途中でもコンポーネントコンテナが製品を保持します。
製品を待機させたいときは、"ディレイ"ステートメントを使います。
"Sink"をクリックします。
"TransportIn:~"を選択した状態で、"ステートメント"-"ディレイ"をクリックします。
追加された"Delay:~"を選択し、[ステートメントプロパティ]ウィンドウから"分布"を"30"に変更します。
シミュレーションを再生します。
"Sink"で30秒のディレイが設定できました。
"Parametric Lathe"の"TransportOut:~"の[目的地]と"Sink"の"TransportIn:~"の"ソース"は、「次のプロセスへ」と"前のプロセスから"になっています。
"Parametric Lathe"の処理が終わっても、"Sink"が"Remove:~"まで実行して再度"TransportIn:~"が実行されるまで、"Parametric Lathe"は"TransportOut:~"を実行して待機します。
輸送先のステートメントの実行にかかわらず製品を輸送したい場合は、コンポーネントコンテナを使う設定にする必要があります。
今回の"Parametric Lathe-Sink"のように直接コンポーネントコンテナを持つ部品でつながっていないようなプロセス間でコンポーネントコンテナを使う輸送をする場合は、Transport Nodeを使用します。
Transport Nodeは、輸送元と輸送先の間に経由地を指定するコンポーネントです。
"Parametric Lathe"をクリックします。
"TransportOut:~"を選択し、[ステートメントプロパティ]ウィンドウから[目的地]を「トランスポートノードへ」に変更します。
"宛先ノード"には、輸送先となるプロセスを設定します。
今回の場合、"Sink Process::TransportNode"を設定します。
"Sink"をクリックします。
"TransportIn:~"を選択し、"ソース"を"コンポーネントコンテナから"に変更します。
シミュレーションを再生します。
"Sink"の状況にかかわらず、"Parametric Lathe"で処理された製品は「Conveyor #2」へ輸送されるようになります。
以上で、「製品の輸送元と輸送先の設定を知ろう」を終わります。
ご視聴ありがとうございました。

=================================================================================

製品をアタッチ・デタッチしてみよう


製品同士をアタッチし、搬送後にデタッチする方法（アタッチステートメント、デタッチステートメント）
https://youtu.be/gslH87FigPw
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_174.zip

製品同士をアタッチし、コンベアで搬送後、デタッチする方法について説明します。
設定が完了すると、Annaが製品を運び箱の中へ格納後、箱と製品が一緒にコンベアを流れ、Ottoが箱から製品を取り出して製品のみ運びます。
本動画の内容には、バージョン1.46では使用できない機能が含まれています。
バージョン1.48以降を使用してください。
付属ファイル「Attach Detouch_before.vcmx」を開きます。
シミュレーションを実行します。
コンベア上を箱が流れていき、製品が生成され、机に格納された製品を、Annaがコンベア上に置きます。
シミュレーションをリセットします。
Annaが製品を箱の中に入れ、箱と製品をアタッチするように設定します。
[プロセス]タブの[エディタ]グループから、[プロセス]を選択します。
[プロセス]は製品が移動する経路の中継地点の作業内容を設定できます。
[Process #1]のプロセスラベルを選択し、プロセスを表示します。
はじめに、箱を[TransportIn]に搬入します。
[TransportIn]を選択します。
搬入した箱の変数名を定義するため、[ステートメントプロパティ]ウィンドウの[製品変数名]を「Box」に変更します。
製品フィルターを設定することで、搬入するものを箱に限定できます。
製品フィルターについての詳細は、FAサイトの使用方法解説動画「輸送する製品を制限してみよう」をご参照ください。
製品フィルターを展開します。
製品フィルターを有効にするため、製品タイプにチェックを入れます。
[TransportIn]に搬入するものを箱に限定するため、[使用可能な製品タイプ]を展開し、「Box」を選択します。
次に、製品を搬入できるように設定します。
プロセスの[ステートメント]を展開し、[プロセスフローステートメント]から[トランスポートインパターン]を選択します。
[トランスポートインパターン]は、搬入する製品の位置や、個数を設定できます。
[ステートメントプロパティ]ウィンドウの[オフセット]の[Tx]と[Ty]に、「-100」と入力します。
[パターンカウント]で搬入する製品の個数を設定します。
今回は、4つ製品を搬入するため、デフォルトのまま使用します。
[パターンステップ]で製品同士の距離を設定します。
[X]と[Y]に、「200」と入力します。
搬入した製品の変数名を定義するため、[製品変数名]を「Bottle」に変更します。
製品フィルターを展開し、[製品フィルターを追加]から[製品タイプ]を選択します。
箱と同様に、[TransportPatternIn]に搬入するものを製品に限定するため、[使用可能な製品タイプ]を展開し、「Bottle」を選択します。
箱と製品をアタッチするように設定します。
[ステートメント]を展開し、[プロセスステートメント]から[アタッチ]を選択します。
[アタッチ]は、親製品に子製品を取り付けることができます。
アタッチすることで親と共に子が移動します。
[ステートメントプロパティ]ウィンドウの、[親]と[子]に製品変数名を入力することで、製品を指定できます。
[親]を「Box」、子を「Bottle」に変更します。
[TransportOut]で製品がアタッチされた箱を搬出します。
[TransportOut]を選択し、[ステートメントプロパティ]ウィンドウの[製品変数名]を「Box」に変更します。
シミュレーションを実行します。
箱の中に製品が入り、箱と製品がアタッチされていることが分かります。
シミュレーションをリセットします。
次のプロセスへ搬送後、箱から製品をデタッチし、Ottoが製品を取り出すように設定します。
[Process #2]のプロセスラベルを選択し、プロセスを表示します。
[TransportIn]を選択します。
搬入した製品の変数名を定義するため、[ステートメントプロパティ]ウィンドウの[製品変数名]を「Box」に変更します。
箱と製品をデタッチするように設定します。
[ステートメント]を展開し、[プロセスステートメント]から[デタッチ]を選択します。
[デタッチ]は、親製品から子製品を取り外すことができます。
[ステートメントプロパティ]ウィンドウの[製品変数名]を[TransportIn]で定義した「Box」に変更します。
[多くをデタッチ]にチェックを付けることで、全ての製品を取り外すことができます。
デタッチした製品の名前を定義するため、[デタッチ変数名]を[Bottle]に変更します。
デタッチした製品と箱を搬出します。
製品と箱をそれぞれ搬出するため、[TransportOut]をコピーし、貼り付け、2つ目の[TransportOut]を作成します。
Ottoが製品を取り出してから、箱をコンベアへ流すようにするため、「Bottle」、「Box」の順に搬出します。
1つ目の[TransportOut]の[ステートメントプロパティ]ウィンドウ、[製品変数名]を「Bottle」に変更します。
2つ目の[TransportOut]を選択し、[ステートメントプロパティ]ウィンドウ、[製品変数名]を「Box」に変更します。
「Box」は、[目的地]を[コンポーネントコンテナへ]に変更することで、コンベアへ搬出できます。
箱がコンベア上を流れるように設定します。
[Sink]のプロセスラベルを選択し、プロセスを表示します。
[TransportIn]を選択し、[ソース]を[コンポーネントコンテナから]に変更します。
シミュレーションを実行します。
Annaが製品を運び箱の中へ格納後コンベア上を流れ、Ottoが製品を運んでいることが分かります。
シミュレーションをリセットします。
製品同士をアタッチし、コンベアで搬送後、デタッチする方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

製品を変形させよう

搬送中の製品のプロパティを変更して、変形させる方法
https://youtu.be/gPZUG3CiF5M
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_181.zip

製品を変形させる方法について説明します。
シミュレーション中に、搬送中の製品を変形させる方法は、2通りあります。
1つ目は、プロセスステートメント「タイプを変更」を使用し、見た目が異なる製品に変更する方法です。
2つ目は、プロパティの値によって変形可能なコンポーネントを製品として登録し、シミュレーション中にプロパティの値を変更する方法です。
本動画では、2つ目の方法について説明します。
事前ファイル「CloseBox_before.vcmx」を開きます。
シミュレーションを実行します。
製品がコンベア上を移動しています。
シミュレーションをリセットします。
製品を缶から、可動部がある箱に変更します。
3Dワールドに配置されているFolding Boxを、製品として使用します。
Folding Boxは、eカタログのPackagingに登録されています。
Folding Boxは、プロパティの値によって変形可能です。
今回は、底面を閉じた状態にしてあります。
製品の情報を定義するため、[プロセス]タブ-[エディタ]グループの[製品]を選択します。
プロセスモデリングでは、[製品タイプエディタ]ウィンドウの、製品タイプに、製品の名前と、見た目を登録できます。
[フローグループ番号1]-[VC_Can]を選択します。
製品タイプ[VC_Can]は、Feederを3Dワールドに配置した時、自動的に追加されます。
[プロパティ]ウィンドウの[Name]をBoxに変更します。
[コンポーネントURI]で、製品の見た目を変更できます。
製品として使用するコンポーネントが、3Dワールドにある場合、[コンポーネントURI]-[...]の右側のアイコンを選択します。
3Dワールドで、箱を選択します。
製品タイプに定義されている製品の詳細設定を更新します。
[製品タイプエディタ]ウィンドウ、[Box]の左側にある[+]アイコンを選択します。
製品の詳細設定である[製品プロパティ]と、[コンポーネントプロパティ]を、確認できます。
[コンポーネントプロパティ]には、缶の詳細設定が残っています。
[コンポーネントプロパティ]を選択します。
右クリック、[すべて削除]を選択することで、すべてのコンポーネントプロパティを削除できます。
箱の詳細設定を追加します。
[コンポーネントプロパティ]を選択した状態で、右クリック、[コンポーネントプロパティを追加]-[すべてのテンプレートプロパティ]を選択します。
Material等の設定が追加されたことがわかります。
シミュレーションを実行します。
箱がコンベア上を移動することがわかります。
シミュレーションをリセットします。
箱のふたを閉じるため、可動部の現在値が入力される項目を確認します。
箱を選択します。
[コンポーネントプロパティ]ウィンドウの、[TopFront]と、[TopSide]が、可動部の現在値です。
[TopFront]と、[TopSide]の値を変更することで、2枚1組のふたが動作することがわかります。
コンベアの作業場所に、処理を追加し、箱の可動部を動作させます。
[エディタ]グループの[プロセス]を選択し、実行する処理を設定できます。
[InlineProcess]を選択します。
製品をTransportInで搬入し、TransportOutで、搬出します。
搬入した製品には、InlineProcessでのみ、使用可能な名前が付与されます。
TransportInを選択し、[ステートメントプロパティ]ウィンドウの[製品変数名]で確認できます。
名前は、ProductInです。
処理を追加するため、[ステートメント]アイコンを選択します。
[フローコントロールステートメント]から[WHILE]を選択します。
WHILEステートメントは、条件を満たしている間、範囲内の処理を繰り返し実行できます。
Whileを、TransportInの下にドラッグします。
箱の可動部が90未満の場合、処理を繰り返し実行します。
[ステートメントプロパティ]ウィンドウの[コンディション]に、処理を実行する条件を設定できます。
「ProductIn.」と入力することで、搬入した製品に関する情報を取得できます。
「Component.」と追記し、製品のコンポーネント情報を取得します。
可動部の現在値が90未満の場合、処理を実行するため、[TopFront<90]と追記します。
可動部の現在値が90未満の場合、可動部の現在値に1加算します。
[ステートメント]アイコンを選択します。
[フローコントロールステートメント]から[変数を割り当てる]を選択します。
変数を割り当てるステートメントは、指定した変数に値を入力できます。
Assignを、Whileの<empty>にドラッグします。
[ステートメントプロパティ]ウィンドウの、[ターゲットプロパティ]は、変数の名前、[数式値]は、入力する値です。
[ターゲットプロパティ]に、「ProductIn.Component.TopFront」と入力します。
[数式値]に、「ProductIn.Component.TopFront+1」と入力することで、処理を繰り返すたびに、TopFrontに1加算されます。
可動部の動作と、人の作業を交互に実行することで、人が箱を閉じているような動作を設定します。
[ステートメント]アイコンを選択します。
[その他のステートメント]から[作業]を選択します。
作業ステートメントは、作業者を制御しているコントローラを指定し、任意の時間、作業者を動作させることができます。
Workを、Assignの下にドラッグします。
[ステートメントプロパティ]ウィンドウの[コントローラー]で、人やロボットなどの作業者を制御しているコントローラーを指定できます。
「Human Transport Controller」を選択します。
[時間ソース]は、作業時間の計算方法に、関数、または任意の計算式を選択できます。
分布を選択し、関数を使用します。
[プロセス時間]は、計算に使用する関数を選択できます。
[+]アイコンを選択します。
[ProcessTime]ウィンドウの[分布]で関数を選択できます。
使用できる関数は、[ヘルプ]タブ-[ヘルプファイル]-[式]-[関数]-[疑似ランダム分布関数]で確認できます。
今回、作業時間には固定の数値を設定するため、[定数値]を選択します。
[値]に、0.1と入力します。
[リソースポジションフレーム]は、作業者の立ち位置を指定できます。
[Null]の場合、Inline Processの[FlowInResourceLocation]が立ち位置になります。
同様に、TopSideを動作させます。
Whileを選択し、右クリック、[コピー]を選択します。
右クリック、[貼り付け]を選択します。
Whileの範囲内にあるステートメントも、同時にコピーされます。
1つ目のWhileの下にドラッグします。
2つ目のWhileの条件を変更します。
[ステートメントプロパティ]ウィンドウの[コンディション]をTopFrontからTopSideに変更します。
同様に、AssignのすべてのTopFrontを、TopSideに変更します。
シミュレーションを実行します。
箱がコンベアの中央で停止します。
箱のふたが閉じ、同時に人が手を動かしているように見えます。
シミュレーションをリセットします。
製品を変形させる方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

製品搬入のタイミングを変更してみよう

製品を搬入する時に、直前の処理が完了するまで待機する方法（トランスポートイン開始、トランスポート待機）
https://youtu.be/B0_-4IgB2sM
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_125.zip

本動画では、製品を搬入する時に、直前の処理が完了するまで待機するようにする方法について説明します。
"トランスポートイン開始"ステートメントと"トランスポート待機"ステートメントを使用します。
初めに、「製品搬入のタイミングを変更してみよう.vcmx」を開きます。
シミュレーションを再生します。
BoxとCanがManualProcessへ輸送されます。
シミュレーションをリセットします。
[プロセス]タブ-[エディタ]-[プロセス]をクリックし、"ManualProcess"をクリックします。
再度、シミュレーションを再生します。
StartTransportInでCanの搬入を始めますが、Delayの実行中にBoxの中に搬入してしまいます。
Delayが完了するまで、Canの搬入は待機するように設定を変更します。
シミュレーションをリセットします。
[エディタ]-[フロー]をクリックします。
3Dワールド上の人アイコンのトランスポートリンクをクリックします。
[プロパティ]ウィンドウの"WaitForNextTransport"は、"トランスポートイン開始"ステートメントや"トランスポートアウト開始"ステートメントを実行する時に、"トランポート待機"ステートメントが実行されるまで、リソースが製品を持った状態で待機する設定です。
"WaitForNextTransport"にチェックを入れて、シミュレーションを再生します。
"Delay:60s"が完了して"WaitTransport:~"が実行されるまで、Humanが"Can"を持った状態で製品の搬入は待機するようになります。
以上で、「製品搬入のタイミングを変更してみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

組み立てや分解ができる製品を定義しよう

製品タイプエディタでのアセンブリの設定とアセンブリエディタの使い方
https://youtu.be/YfLPtDzNWRM
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_061.zip

本動画では、アセンブリの定義の仕方を説明します。
アセンブリとは、製品をアセンブリステップという階層的な構造で定義したものです。
アセンブリを使用することで、シミュレーション中に製品を組み立て、分解が可能になります。
アセンブリの定義には、製品タイプエディタに登録されているパーツを使用します。
そのため、まず、パーツを製品タイプエディタに追加します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Products and Containers]から"Euro Pallet"、"Parametric Pallet"、"Crate"を3Dワールド上にドラッグ&ドロップします。
3Dワールド上の「Parametric Pallet」を選択して、[コンポーネントプロパティ]ウィンドウ-[既定]タブから"palletW"を"800"、"palletL"を"1200"に変更します。
[プロセス]タブ-[エディタ]-[製品]をクリックします。
[製品タイプエディタ]ウィンドウ-"製品を定義"-"製品タイプを追加"を配置したパーツの数クリックします。
"フローグループ番号1"をダブルクリックして名前を"Parts"に変更します。
"製品タイプ番号1"を選択します。
[プロパティ]ウィンドウから[Name]を"Pallet"に変更し、"Pick Component from 3D world"をクリックして3Dワールド上の「Euro Pallet」を選択します。
"製品タイプ番号2"を選択します。
[プロパティ]ウィンドウから[Name]を"Sheet"に変更し、"Pick Component from 3D world"をクリックして3Dワールド上の「Parametric Pallet」を選択します。
"製品タイプ番号3"を選択します。
[プロパティ]ウィンドウから[Name]を"Crate"に変更し、"Pick Component from 3D world"をクリックして3Dワールド上の「Crate」を選択します。
これで、アセンブリで使用するパーツの設定ができました。
次に、製品タイプエディタにアセンブリとアセンブリステップを追加します。
"製品の定義"-"フローグループを追加"と"アセンブリを追加"をクリックします。
"フローグループ番号1"の名前を"FullPallets"に変更します。
"アセンブリ番号1"を選択して[プロパティ]から[名前]を"FullPalletsAssembly"に変更します。
[製品タイプエディタ]ウィンドウの"FullPalletsAssembly"を展開します。
"ステップ番号1"は親アセンブリステップであり、削除や移動はできません。
"ステップ番号1"を選択した状態で右クリックし"ステップを追加"をクリックすると、選択したアセンブリステップを親アセンブリステップとする、子アセンブリステップが追加されます。
追加された"ステップ番号2"を右クリックして"ステップを追加"をクリックします。
"ステップ番号1"を選択して、[名前]を"PalletAssembly"に変更します。
"ステップ番号2"を選択して、[名前]を"SheetAssembly"に変更します。
"ステップ番号3"を選択して、[名前]を"CratesAssembly"に変更します。
追加したアセンブリステップに、パーツを割り当てます。
アセンブリかアセンブリステップを選択し、"アセンブリエディタを開く"をクリックします。
アセンブリエディタを開いた状態で[製品タイプエディタ]ウィンドウ-"FullPalletsAssembly"-"PalletAssembly"をクリックします。
アセンブリエディタ上の黄色のボックスをクリックします。
この黄色のボックスはアセンブリスロットといい、アセンブリスロット1つに対して1つパーツを割り当てることができます。
"既定の製品タイプ"は、アセンブリスロットに割り当てるパーツを設定します。
このアセンブリスロットには、"Pallet"を割り当てます。
"オーダー・インデックス"は、生成される時の順番を設定します。
同値のアセンブリスロットがある場合は、同時に生成されます。
"全製品タイプを受け入れ"にチェックを入れると、すべての製品タイプを受け入れることができます。
チェックを外すと、製品タイプやフローグループで受け入れる製品を指定することができます。
"既定の境界線の寸法"は、"既定の製品タイプ"が"Null"の時などで表示される黄色のボックスのサイズを設定します。
他のアセンブリステップの設定を行います。
[製品タイプエディタ]ウィンドウ-"FullPalletsAssembly"-"SheetAssembly"をクリックします。
アセンブリエディタ上には、黄色のボックスと青色のパレットが表示されています。
青色のパレットは親アセンブリステップのアセンブリスロットである「PalletAssembly - アセンブリスロット」です。
選択しているアセンブリステップ以外のアセンブリスロットの表示方法は、アセンブリエディタ右上のツールバーにある"アセンブリ可視化"で設定ができます。
現在の「PalletAssembly – アセンブリスロット」のように青色で表示されているスロットはゴースト化と言い、このアセンブリエディタ上では選択や移動などができません。
「ゴースト化した親と共に選択したステップを表示します。」は、現在選択しているアセンブリステップとその親アセンブリステップを表示します。
親アセンブリステップは、ゴースト化した状態で表示します。
「アセンブリ全体を表示します。」は、アセンブリステップを全て表示します。
「選択したステップを表示するとその他のステップがゴースト化されます。」は、[製品タイプエディタ]ウィンドウで選択したアセンブリステップ以外をゴースト化した状態にして、アセンブリステップを全て表示します。
「SheetAssembly-アセンブリスロット」を選択し、"既定の製品タイプ"を"Sheet"に変更します。
「PalletAssembly – アセンブリスロット」上に「SheetAssembly – アセンブリスロット」を配置します。
最後に、"CratesAssembly"の設定を行います。
[製品タイプエディタ]ウィンドウ-"FullPalletsAssembly"-"CratesAssembly"をクリックします。
「CratesAssembly - アセンブリスロット」を選択し、"既定の製品タイプ"を"Crate"に変更します。
「CratesAssembly – アセンブリスロット」を「SheetAssembly – アセンブリスロット」上に配置します。
アセンブリスロット1つにつき、割り当てるパーツは1つだけです。
そのため、配置するパーツの数を増やす場合は、アセンブリエディタ右上のツールバーにある"スロットを追加"をクリックしてアセンブリスロットを追加する必要があります。
"スロットを追加"には単一追加と複数追加の2種類があります。
プラスアイコンの"スロットを追加"は、アセンブリスロットを1つ追加します。
アセンブリエディタ上のアセンブリスロットを選択した状態でクリックした場合は、選択していたアセンブリスロットのコピーを追加します。
アセンブリスロットを選択していない状態でクリックした場合は、"既定の製品タイプ"が"Null"のアセンブリスロットを追加します。
9個の四角形アイコンの"スロットを追加"は、パターン化した複数のアセンブリスロットを追加します。
アセンブリエディタ上のアセンブリスロットを選択した状態でクリックした場合、画面右側に"スロットを追加"ウィンドウが表示されます。
追加するアセンブリの個数やレイアウトなど設定し、"適用"をクリックすることで選択していたアセンブリスロットを追加します。
アセンブリスロットを選択していない状態の場合は、こちらの"スロットを追加"は使用できません。
今回は、9個の四角形アイコンの"スロットを追加"で、アセンブリスロットを追加します。
「CratesAssembly-アセンブリスロット」を選択した状態で、9個の四角形アイコンの"スロットを追加"をクリックします。
任意の設定を行い、"適用"をクリックします。
アセンブリスロットが追加できたら、アセンブリスロットの位置を調整してください。
アセンブリを実際に生成します。
アセンブリエディタを閉じます。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Conveyors]から"Conveyor"を3Dワールド上にドラッグ&ドロップします。
[タイプ別モデル]-[PM Flow Components]から"Feeder"を3Dワールド上にドラッグ&ドロップします。
[マニピュレーション]-[PnP]をクリックして、「Feeder」をドラッグして「Conveyor」に近づけ、PnPで接続します。
3Dワールド上の「Feeder」を選択し、[コンポーネントプロパティ]ウィンドウ-[ProductCreator]をクリックします。
"パーツ"を"FullPalletsAssembly"に変更します。
シミュレーションを再生すると、アセンブリエディタで設定したアセンブリが生成できました。
以上で、「組み立てや分解ができる製品を定義しよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

天井クレーンを使ってみよう

天井クレーンで製品を搬送する方法（Dual Rail Transport Controller、Crane）
https://youtu.be/OmQdOHLvBZ0
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_183.zip

本動画では、天井クレーンについて説明します。
天井クレーンとは、工場や倉庫などの室内で重い荷物を移動させるために使用されるクレーンです。
クレーンとコントローラーを接続し、天井クレーンを作成します。
本動画では、バージョン1.410以降のeカタログを使用しています。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Transport Controllers]から、[Dual Rail Transport Controller]を、3Dワールドにドラッグ＆ドロップします。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Cranes]から、[Double Girder Crane]を、3Dワールドにドラッグ＆ドロップします。
[ホーム]タブ-[マニピュレーション]グループの[PnP]を選択し、[Dual Rail Transport Controller]と[Double Girder Crane]を接続します。
3Dワールドの[Dual Rail Transport Controller]を選択し、[コンポーネントプロパティ]ウィンドウを表示します。
[既定]タブの[RunwayLength]は、長さを変更できます。
[RunwaySpan]は、幅を変更できます。
[RunwayHeight]は、高さを変更できます。
[RailWidth]は、走行レールと支柱の幅を変更できます。
[RailHeight]は、走行レールの高さを変更できます。
[AmountOfSupports]は、支柱の本数を変更できます。
[SafetyClearance]は、クレーン同士が設定した距離に達したら、安全のためシミュレーションを停止します。
[CheckLimits]にチェックを入れることで、走行レール外に製品や製品の搬送先がある場合、シミュレーションを一時停止し、[出力]ウィンドウに警告を表記できます。
[Auto Configure Links]を選択することで、複数のクレーンが接続されている場合、距離を優先し製品を搬送します。
[LinkDefaults]タブを選択します。
[GraspTime]は、フックが降下し製品をアタッチするまでにかかる時間を変更できます。
[ReleaseTime]は、フックが降下し製品をデタッチするまでにかかる時間を変更できます。
[GraspFrom]は、フックが製品をアタッチする位置を変更できます。
[PickApproach]は、製品をアタッチするまでの待機位置を変更できます。
[PlaceApproach]は、製品をデタッチするまでの待機位置を変更できます。
[フロー]の設定から、トランスポートリンクを選択し[UseCustomParameters]にチェックを入れることでトランスポートリンクごとに設定することもできます。
3Dワールドの[Double Girder Crane]を選択し、[コンポーネントプロパティ]ウィンドウを表示します。
[既定]タブの[BridgePosition]は、天井クレーンの位置を変更できます。
シミュレーションを実行することで、コントローラーの長さに合わせたクレーンの可動範囲が設定され、値を変更できます。
[Gripper]は、幅を変更できますが、デフォルトでは非表示となっています。
ProfessionalまたはPremiumライセンスでは、[モデリング]タブから、[Gripper]を表示できます。
[コンポーネントグラフ]ウィンドウの[+]アイコンを選択し、コンポーネントの階層構造を展開します。
[Gripper]を選択し、[コンポーネントグラフ]ウィンドウ下側の[+]アイコンをクリックします。
[Block_4]を選択し、[フィーチャプロパティ]の[表示]にチェックを入れることで表示できます。
[コンポーネントグラフ]ウィンドウ-[GripperPlate1]も同様にチェックを入れることで、反対側のグリッパーを表示できます。
[TrolleyPosition]は、巻き上げ機の位置を変更できます。
[HoistPosition]は、フックの位置を変更できます。
[Hook]は、角度を変更できます。
[SlingLength]は、吊り具の長さを変更できます。
[RailWidth]は、サドルと巻き上げ機の大きさを変更できます。
[BridgeWidth]は、ガーダの幅を変更できます。
[BridgeLength]は、ガーダの長さを変更できます。
[BridgeRailHeight]は、ガーダの高さを変更できます。
[TrolleyLength]は、巻き上げ機の長さを変更できます。
[AutoHoming]タブを選択します。
[Delay]で設定した時間が経過すると、各[Position]の位置に移動し待機します。
[Delay]に「3」、各[Position]に「500」と入力します。
シミュレーションを実行します。
[Delay]で設定した時間が経過すると、[Position]の位置に移動することが分かります。
シミュレーションをリセットします。
[Read Current Joint Values]は、現在値を読み取り、値を反映します。
[Speeds]タブを選択します。
ガーダ、巻き上げ機、フックの上下する速度を変更できます。
天井クレーンを使用し、製品を搬送します。
[Feeder Process]、[Process Node]、[Sink Process]、[Human (Anna)]、[Human Transport Controller]、[Idle Location]を追加します。
追加した人と[Idle Location]をコントローラーで制御するため、コントローラーに接続します。
[ホーム]タブの[接続]グループから、[インターフェース]を選択します。
[Human Transport Controller]を選択することで、インターフェースエディタを表示できます。
[Human Transport Controller]で[Resources]を選択し、[Human (Anna)]右側の丸をクリックすることで、接続できます。
クリックではなく、ドラッグすることでも、接続できます。
[インターフェースに接続]ウィンドウから接続する[コンポーネント]と[インターフェース]を選択すると、[このリストからインターフェースに接続]に接続可能なインターフェースが表示されます。
リストの中から選択することでも接続できます。
同様に、[Human Transport Controller]の[Idle/ChargingLocations]を選択し、[Idle Location]と接続します。
[閉じる]を選択します。
フローを設定し、天井クレーンが製品を搬送するように設定します。
[プロセス]タブから、[エディタ]グループの[フロー]を選択します。
3Dワールドに表示された青い丸をプロセスノード、青い丸にカーソルを合わせると表示される名前をプロセスラベルと言います。
プロセスノードは、製品を搬送する経路の中継地点、プロセスラベルは中継地点の名前です。
3Dワールドと、[プロセスフローエディタ]ウィンドウに搬送経路を追加します。
[プロセスフローエディタ]ウィンドウの[フローグループ番号1]を選択します。
はじめに、人が[Feeder]から[Process #1]へ製品を運ぶため、人を制御しているコントローラーのアイコンを選択します。
[Feeder]、[Process #1]の順にプロセスラベルを選択します。
次に、天井クレーンが[Process ＃1]から[Sink]へ製品を運ぶため、天井クレーンを制御しているコントローラーのアイコンを選択します。
[Process #1]、[Sink]の順にプロセスラベルを選択します。
シミュレーションを実行します。
人、天井クレーンの順に製品を搬送しますが、[出力]ウィンドウにエラーが表記されます。
シミュレーションをリセットします。
人が天井クレーンの柱を障害物として認識していることを示すエラーです。
人が柱を避けて通るように[Pathway Area]を追加します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Navigation]から、[Pathway Area]を2つ、3Dワールドにドラッグ＆ドロップします。
人が柱を避けて通るように、[Pathway Area]の配置を変更します。
人、[Idle Location]と同様に、[Pathway Area]もコントローラーと接続します。
コントローラーの[コンポーネントプロパティ]ウィンドウを表示し、[Connect All Pathways]を選択することで、接続可能なインターフェースと一括で接続できます。
[ホーム]タブの[接続]グループから、[インターフェース]を選択します。
[Human Transport Controller]-[Pathways]を選択すると、コントローラーが全ての[PathwayArea]に接続されていることが分かります。
[Pathway Area]を選択し、[コンポーネントプロパティ]-[Centerline Connect]にチェックを入れることで、人がPathway Areaの中央を通ります。
シミュレーションを実行します。
[出力]ウィンドウに新しいエラーが表記されず、人が柱を避け製品を運んでいることが分かります。
シミュレーションをリセットします。
天井クレーンについての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

統計ダッシュボードのテンプレートチャートを使ってみよう

統計情報のテンプレートチャートの使い方と、オリジナルのテンプレートチャートとレイアウトを作成する方法
https://youtu.be/10g_z3Y7P2E
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_092.zip

本動画では、統計情報にあらかじめ登録されているテンプレートチャートを使って、統計情報を表示する方法について説明します。
まず初めに、「統計ダッシュボードのテンプレートチャートを使ってみよう.vcmx」を開きます。
[統計情報]をクリックします。
"統計情報"ウィンドウ-"クリエイトクリックすると、8つのテンプレートチャートが確認できます。
テンプレートチャートを使用するには、コンポーネントを選択した状態である必要があります。
テンプレートチャートを選択すると、そのままグラフが生成されます。
"データの期間"は、統計情報を取得する間隔の設定です。
"前回のインターバル"は、統計を設定した間隔毎に更新して、直近の区間のデータを表示します。
例えば、"間隔"を"60"に設定して10分間再生した場合、60秒ごとにデータを更新し、最後に表示されるデータは9分～10分間の間に取得したものになります。
"シミュレーション作動"は、シミュレーションを再生している間の累計を表示します。
各テンプレートチャートの使用用途について説明します。
"使用状況"は、選択しているコンポーネントが"Set Up"状態、または"Busy"状態にあった時間をパーセンテージで表示します。
画面では、Parametric Latheの使用状況を表示しています。
"ステータス"は、選択されたコンポーネントが各状態だった時間を、パーセンテージで表示します。
画面では、Parametric Latheの各状態だった時間を表示しています。
"生産率"は、選択されたコンポーネントが生産、または搬出したコンポーネントの数を表示します。
画面では、Manual Workstationが搬出したコンポーネントの数を表示しています。
"平均パーツ数"は、選択されたコンポーネントの最後の間隔区間における、平均のパーツ数を表示します。
画面では、Warehouse Process Shelfの平均のパーツ数を表示しています。
"平均パーツ時間"は、選択されたコンポーネントが最後の間隔区間内で、パーツが処理されていたり輸送されていたりした時間を表示します。
画面では、Warehouse Process Shelf内のパーツ処理時間を表示しています。
"共同値"は、選択されたコンポーネントの各ジョイントの値を表示します。
画面では、6軸ロボットであるGeneric Articulated Robotのジョイント値を表示しています。
"移動距離"は、選択されたコンポーネントが、シミュレーション中に移動した距離を表示します。
画面では、作業者の移動距離を表示しています。
"バッテリーレベル"は、選択されたコンポーネントの現在の電力残量を表示します。
画面では、AGVの電力残量を表示しています。
テンプレートごとに参照するプロパティが違うため、選択されたコンポーネントに参照するプロパティがない場合は、エラーが出力されて、グラフは生成されません。
例えば「Human」を選択した状態の場合、"使用状況"は作成できますが、"バッテリーレベル"は作成できません。
テンプレートチャートには、グラフを作成後に、チャートの設定をするオプションウィンドウが表示されるものがあります。
例えば、"使用状況"チャートを作成した場合、右側のウィンドウに"使用状況"ウィンドウが追加されます。
このウィンドウは、1度閉じると2度と表示されないため、再設定するには作りなおす必要があります。
そのため、閉じる前に設定が正しくできていることを確認してください。
"ダッシュボード"ウィンドクリックすると、[プロパティ]ウィンドウからチャート内のデータについての設定を変更できます。
グラフには、"データ系列"や[コンポーネントプロパティ]の値をプロットします。
"データ系列"には、共通のプロパティを持つ複数のコンポーネントからデータを含めることができます。
また、複数の"データ系列"をプロットし、独自の"サンプリング間隔"を設定できます。
"サンプリング間隔"は、データの値を収集する間隔を定義します。デフォルトでは"-1"が定義されています。
"-1"のときは、[統計情報]-[間隔]で設定した値を使います。
テンプレートチャートを追加する方法を説明します。
サンプルファイルを使って、テンプレートチャートを追加します。添付のStatistics-Template.zipをダウンロードします。
フォルダーC:\Users\(ユーザー名)\Documents\MITSUBISHI\Gemini\1.45\My Commandsに、Statistics Templateを展開します。
フォルダー内には、アプリケーションファイルが1つとコマンドファイルが2つあります。
コンポーネントのプロパティの値を収集・表示するために ComponentProperty_Template.pyを使用し、統計ビヘイビアのプロパティの値を収集・表示するためにStatisticsProperty_Template.pyを使用します。
テキストエディタなどでComponentProperty_Template.pyを開きます。
"REPORT_PROPERTY_LABEL"は、グラフのラベル名です。グラフの名称には、コンポーネントの名前と":"とREPORT_PROPERTY_LABELの値を連結した文字列が設定されます。
"REPORT_PROPERTY_NAMES"は、ダッシュボードにプロットするプロパティ名のリストです。第1要素のプロパティをデータ系列のデフォルトとして使います。
チャートタイプを変更するには、74行目のcreateChartの第二引数を変更します。チャートタイプとして設定できる定数については、ヘルプのPython APIの定数のページで詳細を確認できます。
"ComponentProperty_Template.py"を閉じます。
次に、StatisticsProperty_Template.pyを開きます。
"REPORT_PROPERTY_LABEL"は、ComponentProperty_Template.pyと同様の、グラフのラベル名です。
"REPORT_STATISTICS_PROPERTY_NAMES"は、ダッシュボードにプロットする"統計ビヘイビアのプロパティ"名のリストです。
ComponentProperty_Template.pyの"REPORT_PROPERTY_NAMES"同様に、長さが2のリストです。
1つ目の要素は名称にIntervalを含む、インターバルベースの統計ビヘイビアのプロパティ、2つ目の要素は名称にIntervalを含まない、シミュレーション再生中の全体から統計情報を取得する統計ビヘイビアのプロパティである必要があります。
"StatisticsProperty_Template.py"を閉じます。
__init__.pyを開きます。
このファイルは、アプリケーションを起動した時にStatistics Templateを読み込んで表示させるための命令文が記述されています。
あらかじめ2つのコマンドが定義されていますが、これらの修正や新規のコマンド追加も行うことができます。
"cmd_name"は、実行するコマンドの名前です。
"file_name"は、読み込むファイルの名前です。
"icon"は、ダッシュボードで表示されるアイコンです。
SVG形式か、SVGを生成するのに必要なパスのポイントを示す文字列である必要があります。
アプリケーションはプログラムファイル内のIconsフォルダーを参照しているので、そこにある画像は相対パスで参照できます。
"cmd_title"は、追加したテンプレートチャートのアイコンに表示されるタイトル名を指定します。
"tooltip"は、追加したテンプレートチャートのアイコンにマウスカーソルを合わせた時に表示する文章の設定です。
内容を確認したら、ファイルを閉じてGeminiを再起動します。
[統計情報]をクリックします。
"統計情報"ウィンドウ-"クリエイトクリックすると、テンプレートチャートに2種類追加されていることを確認できます。
統計情報のオリジナルレイアウトを設定する方法を説明します。
リボンを[モデリング]タブに切り替えます。
任意のコンポーネントを選択します。どのコンポーネントを選択しても構いません。
[動作設定]-[ビヘイビア]-[パイソンスクリプト]を選択します。
パイソンエディタで1行目だけ残してすべて削除します。
以下のようにPythonを記述し、コンパイルします。
"統計情報"をクリックして"統計情報"ウィンドウを開くと、レイアウト"Example"が追加されています。
例では
レイアウトの定義は8行目で指定しています。
引数は次の通りです。
List of List (String layout_name, List (String placeholder_name, Integer column, Integer row, Integer column_span, Integer row_span)))

Python例
from vcScript import *

app = getApplication()
dash = app.Dashboard
tab = dash.createTab("", True)

layouts = tab.Layouts
new_layout = ["Example",["A1",0,0,10,5],["A2",0,5,10,5]]
layouts.append(new_layout)

tab.Layouts = layouts

以上で、「統計ダッシュボードのテンプレートチャートを使ってみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

統計情報を3Dワールド上に表示させてみよう

装置の稼働状態や生産数などを、3Dワールド上でビーコンやテキストなどに表示する方法
https://youtu.be/sjQ0Mw-OlGs
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_058.zip

本動画では、eカタログの統計情報用コンポーネントを使って、統計情報を表示する方法について説明します。
まず初めに、統計情報を取得するレイアウトを配置します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Layouts]から"Turning Machine Layout"をダブルクリックします。
レイアウトを配置できました。
統計情報を取得できるコンポーネントについて説明します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Statistics]をクリックします。
Bar Chartについて説明します。
このコンポーネントは、3Dワールド上に配置して、データを棒グラフで表示できます。
データを取得したいコンポーネントにアタッチして、コンポーネントプロパティから表示するデータを設定します。
今回は、このコンポーネントを使って、「Small Turning Machine #2」の稼働率を表示するように設定します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Statistics]から"Bar Chart"を3Dワールド上にドラッグ&ドロップし、「Small Turning Machine #2」付近に配置します。
「Bar Chart」を選択した状態で[ホーム]タブ-[階層]-[アタッチ]をクリックし、「Small Turning Machine #2」を選択してアタッチします。
[コンポーネントプロパティ]ウィンドウから、表示するデータを設定します。
"DataSeriesAmount"を"3"に変更します。
[コンポーネントプロパティ]ウィンドウの下のほうにプロパティが追加表示されます。
"SeriesComp"はそれぞれ設定済みのため、"SeriesData_1"に"IdlePercentage_Statistics"、"SeriesData_2"に"BusyPercentage_Statistics"、"SeriesData_3"に"BlockPercentage_Statistics"をそれぞれ設定します。
バーのサイズが小さいため、"BarWidth"を"50"に変更します。
シミュレーションを再生します。
「Small Turning Machine #2」の状態を、「Bar Chart」で表示できました。
Bar Chartの説明は以上になります。
Beaconについて説明します。
このコンポーネントは、マシンなどのコンポーネントにアタッチして、現在の状態を色で可視化できます。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Statistics]から"Beacon"を3Dワールド上にドラッグ&ドロップします。
[ツール]-[スナップ]をクリックし、「Beacon」を「Small Turning Machine」の上に配置します。
「Beacon」を選択した状態で、[階層]-[アタッチ]をクリックし、「Small Turning Machine」を選択して「Beacon」を「Small Turning Machine」にアタッチします。
シミュレーションを再生します。
「Small Turning Machine」の状態を、「Beacon」が可視化するようになりました。
マシンの状態に対応した色の設定は、「Beacon」のコンポーネントプロパティ-[StateColors]タブから設定ができます。
Beaconの説明は以上になります。
「Cycle Time (Signals)」について説明します。
このコンポーネントは、シグナルを使ってサイクルタイムを計測できます。
サイクルタイムを計測したいコンポーネントとブール型シグナルを接続し、Trueへのセットをトリガーとして、その間隔を計測します。
Falseをセットすると計測を終了します。
今回は、このコンポーネントを使って、Buffer ConveyorからSmall Turning Machine #2にPart1が投入されるまでのサイクルタイムを測定します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Statistics]から「Cycle Time (Signals)」を3Dワールド上にドラッグ&ドロップします。
ロボットがシグナルを送信するプログラムを作成します。
[プロセス]タブ-[エディタ]-[フロー]をクリックします。
[プロセスフローエディタ]ウィンドウから"TurningCycle1"をクリックします。
このプロセスフローは、パーツ1のプロセスフローの設定です。
"FromRobotBuffer-Small Turning Machine #2のSmallTurning"間のひし形アイコンをクリックします。
[プロパティ]ウィンドウから"RobotMotion"を"Record Routine"に変更します。
シミュレーションを3分程度再生します。再生速度は速くしてもかまいません。
3分程度再生したら、シミュレーションを停止して[プログラム]タブをクリックします。
「GenericRobot」を選択し、[プログラムエディタ]ウィンドウ-"サブプログラム"から"MyRoutine"をクリックします。
"セットバイナリ出力ステートメントをクリックします。
[ステートメントプロパティ]ウィンドウから"バイナリ出力ステートメント"を"101"、"出力値"にチェックを入れます。
"Set Out[101]==True"を先頭に移動させます。
これで、実行開始時にシグナルを送信する"MyRoutine"を作成できました。
「GenericRobot」が"MyRoutine"を実行し、「CycleTime」にシグナルを送信するように設定します。
[プロセス]タブ-[エディタ]-[フロー]をクリックします。
[プロセスフローエディタ]ウィンドウから"TurningCycle1"をクリックして、"FromRobotBuffer- Small Turning Machine #2のSmallTurning"間のひし形アイコンをクリックします。
[プロパティ]ウィンドウから"RobotMotion"を"Execute Routine"に変更します。
[ホーム]タブ-[接続]-[シグナル]をクリックし、「Generic Robot」を選択します。
"出力"の"0"をダブルクリックして"101"に変更します。
横のアイコンをドラッグし、「Cycle Time (Signals)」の"入力"の"0"の横のアイコン上でドロップします。
これで、「GenericRobot」が"MyRoutine"を実行し、「Cycle Time」へシグナルを送信するようになりました。
シミュレーションを再生します。
「GenericRobot」がBuffer ConveyorからSmall Turning Machine #2へPart1が投入する時にシグナルを送信するようになり、[出力]ウィンドウにサイクルタイムが出力されます。
「Cycle Time (Signals)」の説明は以上になります。
Inline Statistics Labelについて説明します。
コンポーネント上に流れてきた製品数から生産率を求めて可視化します。
製品が流れてくるコンポーネント間に配置して接続する必要があります。
今回は、「Conveyor #3」と「Process Sink」の間に接続して生産率を表示します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Statistics]から「Inline Statistics Label」を3Dワールド上にドラッグ&ドロップします。
[マニピュレーション]-[PnP]を選択した状態で「Process Sink」を「Conveyor #3」から遠ざけ、接続を解除します。
「Inline Statistics Label」を「Conveyor #3」に近づけ、接続します。
「Process Sink」を「Inline Statistics Label」に近づけ、接続します。
シミュレーションを再生します。
「Inline Statistics Label」の近くに生産率が表示されます。
Inline Statistics Labelの説明は以上になります。
Inventory Tracking Pointについて説明します。
このコンポーネントは、このコンポーネント上を通過した製品をカウントして、ノートに記録できます。
今回は、「Feeder」が生成する"LatheComp1"と"LatheComp3"を数えます。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Statistics]から"Inventory Tracking Point"を3Dワールド上にドラッグ&ドロップします。
[マニピュレーション]-[PnP]を選択した状態で「Inventory Tracking Point」を「BufferConveyor」に近づけ、接続します。
[コンポーネントプロパティ]ウィンドウ-[Data]タブから、"PropertyToTrack"を"Name"に変更します。
"PropertyToTrack"は、数える時に使用するプロパティを設定します。
シミュレーションを再生します。
「Inventory Tracking Point」のノートを表示すると、統計情報が確認できます。
また、統計情報を記録したノートは、CSVファイルとして出力できます。
Inventory Tracking Pointの説明は以上になります。
Statistics Displayについて説明します。
このコンポーネントは、アタッチしているコンポーネントのKPIを3Dワールド上に表示できます。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Statistics]から「Statistics Display」を3Dワールド上にドラッグ&ドロップします。
[コンポーネントプロパティ]ウィンドウ-[既定]タブから"Attach to Parent"をクリックし、「Small Turning Machine」上にスナップします。
[コンポーネントプロパティ]ウインドウの"ValueType"以下の項目を設定して"Add Line"をクリックすることで、表示項目を追加できます。
また、Noteをエディタで開いて編集することで、表示内容をカスタマイズすることができます。
シミュレーションを再生します。
「Statistics Display」上に「Small Turning Machine」の統計情報が表示されます。
以上で、「統計情報を3Dワールド上に表示させてみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

統計情報を表示してみよう

装置の稼働状態や生産数などを、統計情報のグラフに表示する方法
タイムチャートの表示方法
https://youtu.be/efSJfrWCj3Y
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_070.zip

本動画では、統計情報の表示方法について説明します。
統計機能を使用するには、対象のコンポーネントに統計ビヘイビアを追加。
コンテナタイプのビヘイビアの統計プロパティに追加した統計ビヘイビアを設定の二つの手順を行う必要があります。
また、コンテナタイプのビヘイビアは7種類あります。
・ワンウェイパス（OneWayPath）
・ツーウェイパス（TwoWayPath）
・コンポーネントクリエイター（ComponentCreater）
・コンテナ（ComponentContainer）
・ルーティングルール（RoutingRule）
・パス（PhysicsPath）
・トランスポートプロトコル(TransportProtocol)
実際に統計ビヘイビアを追加し、コンテナタイプの統計プロパティを設定してみましょう。
「統計情報を表示してみよう.vcmx」を開きます。
リボンを[モデリング]タブに切り替えます。
3Dワールド上のコンベアテンプレートを選択します。
リボンの[動作設定]-[ビヘイビア]-[その他]-[統計]をクリックし、統計ビヘイビアを追加します。
[コンポーネントグラフ]-[Conveyor Template]-[ビヘイビア]-[MainPath]を選択します。
[プロパティ]-[統計]を"Statistics"に変更します。
稼働中や待機中などのリソースの状態を統計情報として表示したい場合、"Statistics"に定義する必要があります。
[コンポーネントグラフ]-[Conveyor Template]-[ビヘイビア]-[Statistics]を選択します。
[プロパティ]最下段にある"デフォルト状態をクリエイト"ボタンを押下します。
これでデフォルトの状態と対応するシステム状態が定義されました。
システム状態は次の8種類があります。
・Warmup：ウォームアップ状態
・Break：故障状態
・Idle：待機状態
・Busy：稼働状態
・Blocked：容量の問題でブロックされている状態
・Fail：プロセスが失敗した状態
・Repair：Break状態からの復旧中の状態
・Setup：セットアップ状態
新しい状態を追加したい場合は、"Click To Add Row"をクリックし、状態名と対応するシステム状態を選択します。
"Conveyor Template #2"にも同様の手順を行います。
ロボットやプロセスで制御する装置の場合は、"状態の設定"ステートメントを使用して状態を設定する必要があります。
[プロセス]タブに切り替えます。
リボンの[エディタ]-[プロセス]を選択します。
3Dワールドの"Generic Work Table"を選択し、プロセスルーチンの画面を開きます。
搬入、作業、搬出とプログラムされており、搬出から搬入までを"Idle"、搬入から作業完了までを"Busy"、作業完了から次の搬出までを"Blocked"と定義しています。
この設定は人やAGVには不要です。
eカタログに登録された部品は、ここまでの二つの設定はすべて設定済みです。
実際に統計情報を表示させてみましょう。
[ホーム]タブに切り替えます。
リボンの[統計情報]をクリックします。
"2-列 1-行標準ダッシュボード"を選択し、"クリエイト"ボタンを押下します。
Geminiで表示可能なグラフ種別は、"ラインチャート"、"エリアチャート"、"棒チャート"、"円チャート"の4種類です。
今回は表示するグラフの種別に"円チャート"と"ラインチャート"を選択します。
統計情報ウィンドウの左側を選択し、設定を行います。
[データ系列]-[#1]-[コンポーネント]に"Process Machine - Work Table"を設定します。
[プロパティ]-[データ系列]-[#1]-[プロパティ]に"Statistics.BusyPercentage"を設定します。
[プロパティ]-[系列の追加]ボタンを押下します。
[#2]-[コンポーネント]に"Process Machine - Work Table"を設定します。
[#2]-[コンポーネントプロパティ]に"Statistics.IdlePercentage"を設定します。
統計情報ウィンドウの右側を選択し、設定を行います。
[プロパティ]-[データ系列]-[#1]-[コンポーネント]に"Conveyor Template #2"を設定します。
[プロパティ]-[データ系列]-[#1]-[プロパティ]に"Statistics.PartExited"を設定します。
これはこのコンベアから流れていったワークの数をカウントする指標値です。
リボンの[統計情報]-[間隔]を"1"秒に変更します。
デフォルトでは"60"秒に設定されており、指定した時間に一回統計情報を更新します。
シミュレーションを実行すると、統計情報ウィンドウの左側に稼働率、右側に出荷数のグラフが表示されます。
また、装置の稼働状態に合わせてグラフが更新されることが確認できます。
グラフのプロパティについて説明します。
"名称"はグラフタイトルを設定できます。
"説明文の可視性"は説明文の表示が設定できます。
各データ系列の名称が凡例として表示されます。
"名称"が空の場合はプロパティ名になります。
"タイトルの可視性"はタイトルの表示を設定できます。
タイトルには"名称"で設定した文字列を表示します。
次に、データ系列のプロパティについて説明します。
"名称"はデータの名称を指定します。
"コンポーネント"は、統計情報を表示する対象のコンポーネントを設定します。
複数のコンポーネントを設定することもできます。
"プロパティ"は統計情報として表示するプロパティを設定します。
"厚さ"はグラフのプロットする線などの太さを設定できます。
"統計"ビヘイビアの追加で定義されるプロパティの内容は、ヘルプのvcStatisticsから確認できます。
また、先ほど説明したプロパティ名にIntervalが加わったプロパティもあります。
プロパティの定義は、先ほど説明したプロパティと同じです。
先ほどのプロパティは、シミュレーション開始からの総時間の累計に対する割合です。
Intervalが含まれているものは、統計情報で設定した間隔の秒数の間の累計に対する割合になります。
次にタイムチャートの作り方を説明します。
各工程の始まりと終わりで、フラグのオン/オフをし、そのフラグの値をグラフにプロットすることでタイムチャートを作成します。
[eカタログ]-[タイプ別モデル]-[Misc]-[Visual Components]を選択し、「PM Global Variables」を3D空間上にドラッグアンドドロップします。
[コンポーネントプロパティ]-[UserVariables]タブに切り替えます。
最初のコンベア搬送工程の状態を示す変数を「Flag1」、コンベアからマシンへ人の搬送工程の状態を示す変数を「Flag2」、マシンでの加工工程の状態を示す変数を「Flag3」として追加します。
[プロパティ]の[Name]を「Flag1」、[Type]を「Integer」、[MaxValue]を「1」に設定し、"Define Variable"ボタンをクリックします。
Boolean型の変数は、統計情報のグラフにプロットできないため、0と1の数値のみを扱うInteger型を使用します。
"Flag2"と"Flag3"も同様に設定します。
リボンを[プロセス]タブに切り替えます。
リボンの[エディタ]-[プロセス]を選択します。
"Feeder"プロセスを選択し、先頭に"プロパティ取得"ステートメントを追加します。
追加したステートメントを選択し、画面のようにプロパティを設定します。
・選択したコンポーネント：PM Global Variables
・選択したビヘイビア：Null
・選択したプロパティ：UserVariables::Flag1
・プロパティ名：Flag1
ここでは、コンベア搬送工程の開始を"Flag1"に設定するため、"PM Global Variables"コンポーネントに追加した"Flag1"プロパティを取得します。
"TransportIn"と"TransportOut"の間に"変数を割り当てる"ステートメントを追加します。
追加したステートメントを選択し、画面のようにプロパティを設定します。
次に"FromConveyor"プロセスの設定も行います。
先頭に"プロパティ取得"ステートメントを二つ追加します。
追加したステートメントを選択し、画面のようにプロパティを設定します。
ここではコンベア搬送工程の終了を"Flag1"に人の搬送作業の開始を"Flag2"に設定するために、"PM Global Variables"コンポーネントに追加した"Flag1"プロパティと"Flag2"プロパティを取得します。
"TransportIn"と"TransportOut"の間に"変数を割り当てる"ステートメントを二つ追加します。
追加したステートメントを選択し、画面のようにプロパティを設定します。
ここでは、コンベア搬送工程の終了を示すため、"Flag1"に"0"、人の搬送作業の開始を示すため、"Flag2"に"1"を設定します。
"Generic Work Table"プロセスの設定も行います。
先頭に"プロパティ取得"ステートメントを二つ追加します。
追加したステートメントを選択し、画面のようにプロパティを設定します。
ここでは、人の搬送工程の終了を"Flag2"にマシンの加工工程の設定を"Flag3"にするために、"PM Global Variables"コンポーネントに追加した"Flag2"プロパティと"Flag3"プロパティを取得します。
"TransportIn"と"Delay"の間に"変数を割り当てる"ステートメントを二つ追加します。
追加したステートメントを選択し、画面のようにプロパティを設定します。
人の搬送工程の終了を示すため"Flag2"に"0"、マシンの加工工程の開始を示すため、"Flag3"に"1"を設定します。
DelayとRemoveの間に"変数を割り当てる"ステートメントを追加します。
追加したステートメントを選択し、画面のようにプロパティを設定します。
マシンの加工工程の終了を示すため、"Flag3"に"0"を設定します。
[ホーム]タブに切り替え、"統計情報"をクリックします。
[統計情報]ウィンドウの"新規タブを追加"アイコンをクリックします。
"1-列1-行標準ダッシュボード"を選択し、"クリエイト"をクリックします。
グラフの種別には"エリアチャート"を選択します。
[プロパティ]-[系列の追加]ボタンを2回押下し、系列を二つ追加します。
各系列に次のように設定します。
[統計情報]-[間隔]を"0.1"に設定します。
シミュレーションを開始すると、コンベア搬送、人搬送、加工がそれぞれグラフにプロットされます。
グラフにプロットしたデータは、エクセルとCSVファイルとして出力も可能です。
エクセルファイルとして実際に出力してみます。
[統計情報]-[グラフをエクスポート]-[Excelにエクスポート]を押下します。
エクセルファイルの保存先を指定し、"保存"ボタンを押下します。
ファイルの保存が完了すると、エクセルが自動で起動します。
シミュレーション開始から出力時までのデータが"間隔"ごとに出力されており、稼働中は"1"、非稼働中は"0"になっています。
以上で「統計情報を表示してみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

机が満杯の場合、別の机に搬送しよう

机が満杯の時、別の机に置き、空きができた時、机の空いた場所に製品を搬入する方法
https://youtu.be/eV1tmTPosRM
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_163.zip

机が満杯の時、一時的に別の机に置き、空きができた時、机の空いた場所に搬入する方法について説明します。
付属ファイル「PutElsewhere_before.vcmx」を開きます。
シミュレーションを実行します。
Feederから机までをAnna、机からSinkまでをOttoが搬送していることがわかります。
シミュレーションをリセットします。
机に複数の製品を配置できるように設定を変更します。
[プロセス]タブを開きます。
[エディタ]グループの[プロセス]を選択することで、プロセスノードで行う作業内容を設定できます。
[ManualProcess]を選択します。
現在、TransportIn、TransportOutが設定されており、製品を1つずつ配置できます。
TransportInとTransportOutを選択し、右クリックから[削除]を選択します。
プロセスウィンドウ右上の[ステートメント]アイコンをクリックすることで、新しい作業内容を追加できます。
一定数の製品を搬入完了後、搬出を開始する場合、[トランスポートインパターン]を使用しますが、今回は、搬入と搬出を並行して行います。
ステートメント一覧の[プロセスフローステートメント]から[バッファー]を選択します。
[バッファー]ステートメントは、製品を一時的に保管します。
複数の製品が並行して[バッファー]ステートメントを出入りできます。
製品を配置する位置を設定します。
[ステートメントプロパティ]ウィンドウの[製品ポジションフレーム]は、製品を配置する位置を指定できます。
[製品ポジションフレーム]がNullの場合、製品はプロセスノードの位置に配置されます。
今回は、[製品ポジションフレーム]を、変更しません。
[オフセット]は、最初に配置する製品の位置を[製品ポジションフレーム]から移動させることができます。
製品を2×2×1の合計4つ配置するため、中心がプロセスノードの位置になるように[Tx]、[Ty]に-75と入力します。
[パターンステップ]は、製品同士の距離です。
製品が重ならないようにするため、[X]、[Y]に150、[Z]に0と入力します。
[並列搬入制限]と[並列搬出制限]は、同時に搬入・搬出できる最大数を設定できます。
今回は、1つずつ搬送しますが、同時並行で、搬入と搬出を可能にするため、[並列搬入制限]と[並列搬出制限]に2と入力します。
シミュレーションを実行します。
机の上に製品を4つ配置できます。
手前の机が満杯になると、Annaは机の上に空きができるまで待機していることがわかります。
シミュレーションをリセットします。
手前の机が満杯の場合、奥の机に製品を搬送します。
奥の机は、あくまで一時的な保管場所であるため、FeederからSinkへ搬送するまでに手前の机に搬入する必要があるものとします。
奥の机に、複数の製品を配置できるように設定します。
[エディタ]グループの[プロセス]を選択します。
[ManualProcess]と[ManualProcess#2]のプロセスウィンドウを表示します。
[ManualProcess#2]の[TransportIn]と[TransportOut]を削除します。
[ManualProcess]の[Buffer]を選択し、右クリックから[コピー]を選択します。
[ManualProcess#2]に貼り付けます。
[ステートメントプロパティ]ウィンドウの[パターンカウント]で、製品を配置できる最大数を変更できます。
[X]に3と入力し、3×2×1の合計6つの製品を配置する設定に変更します。
X軸方向に配置する個数を変更したため、最初に配置する製品の位置を変更します。
[オフセット]の[Tx]に「-150」と入力します。
製品の搬送経路を変更します。
[エディタ]グループの[フロー]を選択することで、製品の搬送経路を設定できます。
Annaが、[ManualProcess#2]へ製品を搬送する設定を追加します。
3Dワールドで、Annaを制御しているコントローラーのアイコンを選択します。
[Feeder]、[ManualProcess#2]、[ManualProcess]の順にプロセスノードを選択します。
[ManualProcess#2]のプロセスラベルを、[プロセスフローエディタ]ウィンドウの[Feeder]と[ManualProcess]の間にドラッグ＆ドロップします。
[ManualProcess]が満杯の場合、[ManualProcess#2]に搬送する設定を追加します。
[プロセスフローエディタ]ウィンドウで、[ManualProcess#2]の上に表示されている6角形を選択します。
[プロパティ]ウィンドウの[IsOptional]は、搬送経路の中継地点をスキップするかを設定できます。
満杯ではなくなり、[ManualProcess]に搬入できる場合、[ManualProcess#2]をスキップするため、[IsOptional]にチェックを付けます。
シミュレーションを実行します。
手前の机が満杯の場合、奥の机に製品を搬送していることがわかります。
机に空きができた場合、奥の机から手前の机に製品を搬送しています。
シミュレーションをリセットします。
机が満杯の時、一時的に別の机に置き、空きができた時、机の空いた場所に搬入する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

品種に応じて動作を変えよう

部品の種類に応じて、搬送先や動作を変える方法
https://youtu.be/5yNLm4LAsrg
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_059.zip

本動画では、シミュレーション中に、品種によって異なる処理を設定する方法について説明します。
はじめに、今回使用するコンポーネントを3Dワールドに配置します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Flow Components]から、"Feeder Process"と"Sink Process"を3Dワールド上にドラッグ&ドロップします。
[タイプ別モデル]-[Products and Containers]から"Cube"と"Cylinder"を3Dワールド上にドラッグ&ドロップします。
[タイプ別モデル]-[Machines]から"Parametric Lathe"を2つ3Dワールド上にドラッグ&ドロップします。
「Parametric Lathe #2」をクリックします。
[コンポーネントプロパティ]ウィンドウ-[既定]タブから[名前]を"Process Machine"に変更します。
プロセスフローで使用する製品の定義をします。
[プロセス]タブ-[エディタ]-[製品]をクリックします。
製品タイプに「Cube」を割り当てます。
"フローグループ番号1"-"VC_Can"をクリックします。
[プロパティ]ウィンドウから[Name]を"Cube"に変更します。
"コンポーネントURI"-"Pick Component from 3D world"をクリックし、3Dワールド上の「Cube」を選択します。
同様の手順で、「Cylinder」も割り当てます。
[製品タイプエディタ]ウィンドウ-[製品の定義]-[フローグループを追加]をクリックします。
"フローグループ番号2"を選択した状態で[製品タイプエディタ]ウィンドウ-[製品の定義]-[製品タイプを追加]をクリックします。
"フローグループ番号2"-"製品タイプ番号1"をクリックします。
[プロパティ]ウィンドウから[Name]を"Cylinder"に変更します。
"コンポーネントURI"-"Pick Component from 3D world"をクリックし、3Dワールド上の「Cylinder」を選択します。
これで、生成する製品の定義ができました。
次に、シミュレーション中の動作を設定します。
まず、製品が"Cube"の場合の設定を行います。
[エディタ]-[プロセス]をクリックします。
3Dワールド上の「Process Machine」の"Parametric Lathe"のプロセスラベルをクリックします。
[ルーチンプロパティ]ウィンドウから[名前]を"Cube Process"に変更します。
"ステートメント"-"予約製品"をクリックします。
"予約製品"ステートメントとは、フローグループや製品タイプを指定して、プロセスに受け入れる製品に条件を設定するステートメントです。
"追加された"ReserveProduct:~"を選択します。
[ステートメントプロパティ]ウィンドウから"全製品タイプを受け入れ"のチェックを外します。
"受け入れられた製品タイプ"をクリックし"Cube"を追加します。
[製品変数名]を"Cube"に変更します。
"予約製品"ステートメントを使用する場合、"トランスポートイン"ステートメントの"予約済み変数名"に、"予約製品"ステートメントで設定した[製品変数名]を設定する必要があります。
"TransportIn:~"を選択し、[ステートメントプロパティ]ウィンドウから"予約済み製品変数名"を"Cube"に変更します。
シミュレーション中に処理中のプロセスを確認できるようにするために、製品の色を変えるようにします。
"Delay:1s"を選択した状態で、"ステートメント"-"ノードマテリアルを設定"をクリックします。
製品が"Cube"の場合の設定は以上になります。
次に、製品が"Cylinder"の場合の設定を行います。
3Dワールド上の「Process Machine」の"Cube Process"のプロセスラベルをクリックします。
"新規プロセスルーチン"をクリックします。
"Process #1"をクリックし、[ルーチンプロパティ]ウィンドウから[名前]を"Cylinder Process"に変更します。
"Cylinder Process"を選択した状態で"ステートメント"-"予約製品"をクリックします。
追加された"ReserveProduct:~"を選択します。
[ステートメントプロパティ]ウィンドウから"全製品タイプを受け入れ"のチェックを外します。
"受け入れられた製品タイプ"をクリックし、"Cylinder"を追加します。
[製品変数名]を"Cylinder"に変更します。
"Cube Process"をクリックし、"State Idle"以降を全てコピーします。
"Cylinder Process"をクリックし、ウィンドウ下段をクリックして、先ほどコピーした内容をペーストします。
追加された"TransportIn:~"をクリックし、"予約済み変数名"を"Cylinder"に変更します。
"SetNodeMaterial:~"を選択し、[ステートメントプロパティ]ウィンドウから"マテリアル"を"green"に変更します。
ここまで設定ができたら、3Dワールド上の「Process Machine」を選択し、コピー&ペーストします。
追加した「Process Machine #2」の"Cylinder Process"のプロセスラベルをクリックします。
[ルーチンプロパティ]ウィンドウから[名前]を"Cylinder Process #2"に変更します。
"Cylinder Process #2"の"SetNodeMaterial:~"を選択し、[ステートメントプロパティ]ウィンドウ"から"マテリアル"を"yellow"に変更します。
製品が"Cylinder"の場合の設定は以上になります。
ここまでで、製品毎の動作内容を設定できました。
次に、プロセスフローを作成して、シミュレーション中に製品が輸送されるようにします。
[エディタ]-[フロー]をクリックします。
[プロセスフローエディタ]ウィンドウで"フローグループ番号1"を選択した状態で、"Feeder"のプロセスラベル-"Parametric Lathe"のプロセスラベル-"Cube Process"のプロセスラベル-"Sink"のプロセスラベルと順にクリックします。
[プロセスフローエディタ]ウィンドウの"フローステップ"に、"Feeder"-"Parametric Lathe"-"Cube Process"-"Sink"が追加されます。
[プロセスフローエディタ]ウィンドウで"フローグループ番号2"を選択した状態で、"Feeder"のプロセスラベル-"Parametric Lathe"のプロセスラベル-"Cylinder Process"のプロセスラベル-"Cylinder Process #2"のプロセスラベル-"Sink"のプロセスラベルと順にクリックします。
[プロセスフローエディタ]ウィンドウの"フローステップ"に、"Feeder"-"Parametric Lathe"-"Cylinder Process"-"Cylinder Process #2"-"Sink"が追加されます。
これで、シミュレーション中に製品が輸送されるようになりました。
最後に、「Feeder Process」が"Cube"と"Cylinder"を生成するように設定をします。
「Feeder Process」をクリックします。
[コンポーネントプロパティ]ウィンドウ-[ProductCreator]タブをクリックします。
"フィードモード"を"バッチ"に変更します。
"バッチ"とは、製品毎に個数とインターバルを設定して、定義した個数ずつ順番に製品を生成するモードです。
"パーツを選択"をクリックし、"Cube"と"Cylinder"を選択します。
"Count"と"Interval"が初期値のままだと値が大きいので、それぞれ"Count"を"3"、"Interval"を"5"に変更します。
これで、2種類の製品を生成できるようになりました。
シミュレーションを再生します。
どちらの製品も、「Feeder Process」から「Process Machine」を介して「Sink Process」へ輸送されますが、"Cube"の場合は「Parametric Lathe」-「Process Machine」、または「Process Machine #2」-「Sink Process」、"Cylinder"の場合は「Parametric Lathe」-「Process Machine」-「Process Machine #2」-「Sink Process」と輸送され、製品によって動作内容を変えることができました。
以上で、「品種に応じて動作を変えよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

複数のAGVを待機時間無しで動作させよう

複数のAGVを待機時間無しで動作させる方法
（関連動画：製品の輸送元と輸送先の設定を知ろう）
https://youtu.be/j5V9n_szv6M
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_171.zip

複数のAGVを待機時間無しで動作させる方法について説明します。
関連動画として、FAサイトの使用方法解説動画「製品の輸送元と輸送先の設定を知ろう」もご参照ください。
付属ファイル「No waiting AGV_before.vcmx」を開きます。
移動経路となる[Pathway Area]、製品を生成する[Feeder Process]、目的地となる[Sink Process]が配置されていることを確認します。
製品を運搬するため、AGVを配置します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Mobile Robots]-[Visual Components]から、[Mobile Robot Resource]を、3Dワールドにドラッグ＆ドロップします。
AGVを制御するため、コントローラーを配置します。
[PM Transport Controllers]から、[Mobile Robot Transport Controller]を、3Dワールドにドラッグ＆ドロップします。
AGVをコントローラーで制御するため、AGVとコントローラーを接続します。
[ホーム]タブの[接続]グループから、[インターフェース]を選択します。
[Mobile Robot Transport Controller]を選択することで、インターフェースエディタを表示できます。
[Mobile Robot Transport Controller]で[Resources]を選択し、[Mobile Robot Resource]右側の丸をクリックすることで、接続できます。
クリックではなく、ドラッグすることでも、接続できます。
[インターフェースに接続]ウィンドウから接続する[コンポーネント]と[インターフェース]を選択すると、[このリストからインターフェースに接続]に接続可能なインターフェースが表示されます。
リストの中から選択することでも接続できます。
[閉じる]を選択します。
AGVが移動する範囲を設定するため、Pathway Areaとコントローラーを接続します。
コントローラーの[コンポーネントプロパティ]ウィンドウを表示し、[Connect All Pathways]を選択することで、接続可能なインターフェースと一括で接続できます。
[出力]ウィンドウに、コントローラーと接続された全ての[Pathway Area]が表示されます。
AGVが製品を搬送するための経路を設定します。
はじめに、AGVの移動する方向を指定します。
[Pathway Area]を選択します。
[コンポーネントプロパティ]ウィンドウの[OneWay]にチェックを入れます。
チェックを入れることで、[Pathway Area]の移動する方向を指定できます。
[OneWayHeading]は、移動経路の方向を変更できます。
今回は反時計回りになるように、それぞれ[PathwayArea]の移動経路の方向を変更します。
次に、フローの設定をします。
[フロー]は製品を搬送する流れや、搬送方法を設定できます。
[プロセス]タブから、[エディタ]グループの[フロー]を選択します。
3Dワールドに表示された青い丸をプロセスノード、青い丸にカーソルを合わせると表示される名前をプロセスラベルと言います。
プロセスノードは、製品を搬送する経路の中継地点、プロセスラベルは中継地点の名前です。
3Dワールドと、[プロセスフローエディタ]ウィンドウに搬送経路を追加します。
[プロセスフローエディタ]ウィンドウの[フローグループ番号1]を選択します。
AGVが[Feeder]から[Sink]へ製品を搬送するため、AGVを制御しているコントローラーのアイコンを選択します。
[Feeder]、[Sink]の順にプロセスラベルを選択します。
シミュレーションを実行します。
AGVが、設定した経路を通り、製品を搬送していることが分かります。
シミュレーションをリセットします。
AGVを1台追加し、2台のAGVを稼働させたときの動作を確認します。
3Dワールド上にある[Mobile Robot Resource]をコピー、または[eカタログ]から、3Dワールドにドラッグ＆ドロップします。
AGVの待機場所を配置します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Navigation]から[Idle Location]を、3Dワールドにドラッグ＆ドロップします。
追加したAGVと[Idle Location]を、コントローラーに接続します。
AGVは、1台目のAGVと同様に接続します。
[Idle Location]は、[Mobile Robot Transport Controller]の[Idle/ChargingLocations]から、接続できます。
シミュレーションを実行します。
1台は製品を搬送していますが、残りの1台は[Idle Location]で待機しています。
シミュレーションをリセットします。
待機時間を無くし、2台のAGVが製品を搬送するように設定します。
[プロセス]タブから、[エディタ]グループの[プロセス]を選択します。
[プロセス]は製品が移動する経路の中継地点の作業内容を設定できます。
[Feeder]と[Sink]のプロセスラベルを選択し、プロセスを表示します。
[Feeder]-[TransportOut]-[目的地]は[次のプロセスへ]、[Sink]-[TransportIn]-[ソース]は[前のプロセスから]です。
[次のプロセスへ]、[前のプロセスから]を使用している場合、次のような順番で搬送しています。
[Sink]の[TransportIn]が製品の搬出を要求します。
[TransportIn]の要求を受け、[Feeder]の[TransportOut]が製品①を搬出します。
[Feeder]は[TransportIn]で、自身が作成した製品②を搬入します。
[TransportOut]は製品②の搬出を試みますが、製品①の[Sink]への搬入が完了していないため、[Sink]の[TransportIn]から2回目の製品要求が来ません。
製品①を[Sink]に搬入完了した時、[Sink]プロセスが進みます。
[Sink]の[TransportIn]が2回目の製品要求をすると、[Feeder]は製品②の搬出を開始できます。
したがって、製品の搬送は1つずつのため、次の製品要求が来るまでの待機時間が発生します。
待機時間をなくす方法を説明します。
[Feeder]-[TransportOut]-[目的地]を[トランスポートノードへ]に変更します。
トランスポートノードとは、フローの中継点を指します。
トランスポートノードを指定するため、[宛先ノード]を[Sink Process::TransportNode]に変更します。
本来、受け取る側の[TransportIn]-[ソース]を、送る側の[TransportOut]-[目的地]と一致させる必要があります。
しかし、[トランスポートノードから]という設定がないため、トランスポートノードと紐づいている[コンポーネントコンテナから]を設定します。
待機時間が無くなり、製品を続けて搬送することができます。
シミュレーションを実行します。
2台のAGVが待機することなく、製品を搬送していることが分かります。
シミュレーションをリセットします。
複数のAGVを待機時間無しで動作させる方法についての説明は、以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

複数の作業者が動作するタイミングを合わせよう(1/4)

複数の作業者が一緒に1つの製品を搬送しているような見た目を表現するため、メインの製品と一緒にダミーの製品を搬送させる方法
https://youtu.be/UURSm-hWcDY
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_191_p1.zip

複数の作業者が動作するタイミングを合わせる方法について説明します。
動作するタイミングを合わせることで、複数の作業者が一緒に1つの製品を搬送しているような見た目を表現できます。
本動画では、2人の作業者に、メインの製品と、ダミーの製品を搬送させる設定までを説明します。
事前ファイル「Timing_before.vcmx」を開きます。
シミュレーションを実行します。
Feederで生成された製品を、Annaがコンベアまで搬送しています。
Ottoは、動作しません。
シミュレーションをリセットします。
1つの「Human Transport Controller」に複数の作業者を紐づけて制御した場合、作業指示を出すと、手が空いていて近くにいる作業者が自動的に割り振られます。
作業ごとの作業者個人を指定することはできません。
今回は、異なる立ち位置の作業ごとに作業者個人を指定したいため、「Human Transport Controller」を分けます。
Feederをもう1つ追加し、Feederからコンベアまで製品を搬送する作業者をOttoとします。
3Dワールドで、「Feeder Process」を選択します。
CtrlキーとCを押し、コピーします。
CtrlキーとVを押し、3Dワールドに貼り付けます。
3Dワールドに、「Feeder Process #2」が追加されたことがわかります。
「Feeder Process #2」を移動させます。
[コンポーネントプロパティ]ウィンドウの[座標]を変更し、3Dワールドでの位置を変更します。
[X]は0、[Y]は-400です。
「Feeder Process #2」で生成される製品の搬送経路を設定します。
[プロセス]タブを開きます。
[エディタ]グループの[フロー]を選択することで、製品の搬送経路と搬送方法を設定できます。
3Dワールドに表示された青い丸は、作業場所を表し、プロセスノードと言い、青い丸にカーソルを合わせると表示される文字は、作業場所の名前を表し、プロセスラベルと言います。
プロセスノード同士をつなぐ矢印は、製品の搬送経路と搬送方法を表し、トランスポートリンクと言います。
「Feeder Process」と「Feeder Process #2」のプロセスラベルには、Feederと表示されています。
2つの作業場所を区別するため、名前を変更します。
「Feeder Process #2」のプロセスラベルを、右クリックします。
[ルーチンプロパティ]ウィンドウの[名前]を「Feeder#2」に変更します。
Feeder#2、ToConveyor間にトランスポートリンクを設定します。
Ottoが製品を搬送するため、オレンジ色の人アイコンを選択します。
トランスポートリンクは、3Dワールドと[プロセスフローエディタ]ウィンドウの両方に設定する必要があります。
プロセスラベルを選択することで、3Dワールドと[プロセスフローエディタ]ウィンドウの両方に設定できます。
3Dワールドにのみ設定する場合、プロセスノードを選択します。
選択する順番は、Feeder#2、ToConveyorです。
Feeder#2、ToConveyor間に矢印と、オレンジ色の人アイコンが表示されていることがわかります。
[プロセスフローエディタ]ウィンドウにのみ設定する場合、プロセスラベルを[プロセスフローエディタ]ウィンドウの[フローステップ]に、ドラッグ＆ドロップします。
Feeder#2のプロセスラベルを、[プロセスフローエディタ]ウィンドウの、Feederの下に、ドラッグ＆ドロップします。
シミュレーションを実行します。
AnnaとOttoが、交互に製品を搬送していることがわかります。
シミュレーションをリセットします。
AnnaとOttoが搬送する製品を、生成する設定を変更します。
[エディタ]グループの[製品]を選択することで、生成する製品の情報を定義できます。
[製品タイプエディタ]ウィンドウに、フローグループと、製品タイプが表示されています。
フローグループとは、製品の搬送経路のグループであり、所属する全ての製品タイプは、フローグループに設定された搬送経路に沿って移動します。
製品タイプでは、生成する製品の保有する情報を定義できます。
「フローグループ番号1」に、製品タイプを追加します。
「フローグループ番号1」を選択します。
検索ボックスの右側にある＋アイコンを選択します。
[製品タイプを追加]を選択することで、新しい製品タイプを追加できます。
[プロパティ]ウィンドウで、[Name]を「Dummy」に変更します。
[コンポーネントURI]で、生成する製品の見た目を定義できます。
製品の見た目を定義する方法は3つあります。
1つ目は、外部のコンポーネントファイルを読込む方法です。
[コンポーネントURI]の右側にある[...]を選択し、[開く]ウィンドウで、外部のコンポーネントファイルを指定することで、定義できます。
2つ目は、3Dワールド上のコンポーネントを選択する方法です。
[...]の右側にある[Pick Component from 3D World]アイコンを選択し、3Dワールド上のコンポーネントを選択することで、定義できます。
3つ目は、VCIDを入力し、eカタログのコンポーネントを読込む方法です。
入力ボックスに、「vcid:コンポーネントのVCID」と入力することで、定義できます。
今回は、eカタログのコンポーネントを使用します。
eカタログを表示し、[タイプ別モデル]-[Basic Shapes]の「Block Geo」を選択します。
右クリックし、[メタデータを表示]を選択することで、Block Geoに関する情報を表示できます。
[VCID]を選択し、コピーします。
[プロパティ]ウィンドウの[コンポーネントURI]に「vcid:」と入力後、コピーしたVCIDを貼り付けます。
生成する製品を変更するため、「Feeder Process #2」を選択します。
[コンポーネントプロパティ]ウィンドウの[ProductCreator]タブを選択します。
[パーツ]で、生成する製品の製品タイプを指定できます。
Dummyを選択します。
同様に、VC_Canの製品の見た目を、[タイプ別モデル]-[Products and Containers]のDrumに変更します。
シミュレーションを実行すると、白いブロックと青いドラムが生成されたことがわかります。
作業者の立ち位置を追加します。
作業者の立ちを変更する方法の詳細は、動画「作業者の立ち位置を変更しよう(1/2)」、「作業者の立ち位置を変更しよう(2/2)」を参照してください。
Ottoの立ち位置を指定します。
「To Conveyor Process」を選択します。
[コンポーネントプロパティ]ウィンドウのResouceOffsetの[Tx]を「-800」、[Ty]を「-400」、[Rz]を「0」に変更します。
Annaの立ち位置を指定するため、フレームを追加します。
フレームとは、3Dワールド上で、位置と方向を定義する基準点です。
「To Conveyor Process」を選択し、[ヘルパーツール]から[フレームを作成]を選択します。
[フレームを作成]ウィンドウの[新しいフレーム名]に名前を入力します。
名前は、「NewPosition」です。
既存のフレームの座標を参考にするため、[ここからロケーションをコピー]で、ResourceLocationを選択します。
AnnaとOttoを横に並べるために、[Tx]を-800、[Ty]を400に変更します。
[フレームを作成]するを選択し、新しいフレームを追加します。
[出力]ウィンドウに、フレームが追加されたことを示すメッセージが表示されたことがわかります。
[閉じる]を選択します。
3Dワールドにフレームを表示する場合、3Dワールドツールバーの[フレームタイプ]を展開し、フレームにチェックを付けます。
[フレームタイプ]アイコンが透明な場合、機能は無効となっているため、アイコンを選択し、有効にする必要があります。
3Dワールドに、フレームを表示できます。
現在、ToConveyorは、Feeder、またはFeeder#2の搬出命令のどちらか1つのみを受け付け、コンベアに製品を搬入しています。
もう1つの搬出指令は、実行中の搬送が完了するまで、受けることができません。
Feederの搬出指令を受けながら、同時にFeeder#2の搬出指令を受ける設定に変更します。
トランスポートインステートメントは、製品を搬入することはできますが、他の処理を同時に実行することはできません。
ToConveyorのTransportInを選択し、右クリック、[削除]を選択します。
[ステートメント]アイコンを選択し、追加可能なステートメントの一覧を表示します。
[プロセスフローステートメント]から[トランスポートイン開始]を選択します。
トランスポートイン開始ステートメントは、製品の搬入完了を待つことなく、次の処理を実行できます。
StartTransportInを、TransportOutの上にドラッグ＆ドロップします。
製品を2つ搬入するため、StartTransportInを選択し、右クリック、[コピー]を選択します。
既存のStartTransportInを選択した状態で、右クリック、[貼り付け]を選択します。
StartTransportInの下にTransportOutがある場合、搬入指令と同時に、搬出指令が出されるため、エラーが発生します。
複数のStartTransportInで、同じ製品変数名を使用している場合、すべてのStartTransportInが完了するまで待機します。
搬入される製品の変数名を定義します。
[ステートメントプロパティ]ウィンドウの製品変数名を「ProductIn2」に変更します。
コンベアに製品を搬入する時の作業者の立ち位置を変更するため、[リソースポジションフレーム]をNewPositionに変更します。
製品の搬入が完了するまで、待機します。
[ステートメント]アイコンを選択します。
[プロセスフローステートメント]から[トランスポート待機]を選択します。
トランスポート待機ステートメントは、トランスポートイン開始ステートメント、またはトランスポートアウト開始ステートメントを実行している場合、製品の搬送が完了するまで待機できます。
WaitTransportを、TransportOutの上にドラッグ＆ドロップします。
搬入する製品変数名が2種類あるので、WaitTransportを選択し、右クリック、[コピー]を選択します。
既存のWaitTransportを選択した状態で、右クリック、[貼り付け]を選択します。
[ステートメントプロパティ]ウィンドウの[製品変数名]で指定した製品が搬入完了するまで待機できます。
製品変数名は、1つのプロセス内でのみ使用可能な製品の名前です。
[ステートメントプロパティ]ウィンドウの製品変数名を「ProductIn2」に変更します。
[プロセスフローステートメント]から[製品削除]を選択し、コンベアに白いブロックが流れる前に、白いブロックを削除します。
TransportOutの[ステートメントプロパティ]ウィンドウの製品変数名を[ProductIn2]に変更します。
シミュレーションを実行すると、Ottoが搬送している白いブロックが削除されていることがわかります。
2人の作業者が、メインの製品と、ダミーの製品を搬送させる設定までの説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

複数の作業者が動作するタイミングを合わせよう(2/4)

複数の作業者が一緒に1つの製品を搬送しているような見た目を表現するため、製品を搬入完了するタイミングを合わせる方法
https://youtu.be/evRq6LeAVwc
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_191_p2.zip

複数の作業者が動作するタイミングを合わせる方法について説明します。
本動画では、2人の作業者が、作業場所に製品を搬入完了するタイミングを合わせる方法について説明します。
付属ファイル「Timing_after1.vcmx」を開きます。
コンベア入り口の作業内容を変更します。
[プロセス]タブを開きます。
[エディタ]グループの[プロセス]を選択することで、作業内容を変更できます。
ToConveyorを選択し、作業内容を表示します。
シミュレーションを実行します。
AnnaとOttoが横に並んでコンベアに搬入していることがわかります。
ただし、2組の搬出指令と搬入指令の組み合わせはランダムなため、AnnaとOttoの立ち位置が入れ替わることがあります。
シミュレーションをリセットします。
搬入指令に、特定の製品のみ搬入する条件を設定し、立ち位置の入れ替わりを防ぎます。
ToConveyorの1つ目のStartTransportInを選択します。
作業者の立ち位置は、コンベアの手前側であるため、Ottoにダミーの製品を搬入させます。
[ステートメントプロパティ]ウィンドウの[製品フィルター]を選択します。
製品フィルターについての詳細は、動画「輸送する製品を制限してみよう」を参照してください。
[製品フィルターを追加]アイコン、[製品タイプ]を選択することで、搬入する製品の製品タイプを制限できます。
[使用可能な製品タイプ]をDummyに変更します。
同様に、2つ目のStartTransportInに、製品フィルターを設定します。
搬入する製品の製品タイプは、VC_Canです。
AnnaとOttoの立ち位置が入れ替わることはなくなります。
白いブロックの色を変更します。
[エディタ]グループの[製品]を選択します。
[製品タイプエディタ]ウィンドウの[Dummy]を左側の＋アイコンで展開します。
[コンポーネントプロパティ]を右クリックし、[コンポーネントプロパティを追加]にカーソルを合わせます。
読込んだコンポーネントに、すでにプロパティーが設定されている場合、[すべてのテンプレートプロパティ]を選択することで、一括で製品タイプにコンポーネントプロパティーを定義できます。
追加されたコンポーネントプロパティーの中から、[Material]を選択します。
[プロパティ]ウィンドウの[Material]で、製品の色を変更できます。
glass1を選択します。
シミュレーションを実行すると、Ottoが搬送している白い製品が透明な製品に変更されていることがわかります。
シミュレーションをリセットします。
AnnaとOttoの間で製品搬送する方法について説明します。
[マニピュレーション]-[移動]を選択します。
シミュレーションを実行します。
Humanが製品を搬送しているときに、シミュレーションを一時停止します。
青いドラムを選択します。
製品をAnnaとOttoの間の位置に移動します。
Annaを選択し、[コンポーネントプロパティ]-[Transport]-[Update From Product]をクリックし、Humanが製品を持つ位置を更新します。
シミュレーションをリセットします。
シミュレーションを実行すると、製品を持つ位置が変化していることがわかります。
シミュレーションをリセットします。
2人の作業者が、作業場所に製品を搬入完了するタイミングを合わせる方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

複数の作業者が動作するタイミングを合わせよう(3/4)

複数の作業者が一緒に1つの製品を搬送しているような見た目を表現するため、製品を搬出開始するタイミングを合わせる方法
https://youtu.be/DbG6Eq7VXfQ
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_191_p3.zip

複数の作業者が動作するタイミングを合わせる方法について説明します。
シグナルが指定の値になるまでプロセスの実行を待機させる場合は、動画「シグナルがトリガーされるまでプロセスの実行を待機させよう」を参照してください。
本動画では、複数の作業者が、作業場所から製品を搬出開始するタイミングを合わせる方法について説明します。
付属ファイル「Timing_after2.vcmx」を開きます。
Annaを離れた位置に移動させ、シミュレーションを実行します。
現在、コンベアに、製品を搬入完了する時、タイミングを合わせているため、作業者とFeeder間の距離が異なる場合、1回目の搬送タイミングが合いません。
シミュレーションをリセットします。
製品を、Feederから搬出開始するタイミングを合わせます。
「Feeder Process #2」は、Feeder Processが製品を生成するまで待機し、「Feeder Process」は、「Feeder Process #2」が待機状態から脱するまで待機します。
MELSOFT Gemini Professional、またはPremiumを使用している場合は、[モデリング]タブでシグナルの追加・削除が可能です。
MELSOFT GeminiEssentailsをご使用の方は、[プロセス]タブでシグナルの追加は可能ですが、削除できないため、注意が必要です。
シグナル待機についての詳細は、動画「シグナルがトリガーされるまでプロセスの実行を待機させよう」を参照してください。
Signal Relayについての詳細は、動画「グローバルなシグナルを作ろう」を参照してください。
Feeder Processと「Feeder Process #2」に、待機状態から脱するためのシグナルを追加します。
「Feeder Process」を選択した状態で、[プロセス]タブを開きます。
[ヘルパーツール]グループから[シグナルをクリエイト]を選択することで、選択しているコンポーネントにシグナルを追加できます。
[シグナルをクリエイト]を選択することで、[シグナルをクリエイト]ウィンドウが表示されます。
[シグナルタイプ]で、シグナルのデータ型を指定できます。
[シグナル名]で、シグナルの名前を設定できます。
[シグナルタイプ]はブール型、[シグナル名]は「Flag1」です。
[シグナルをクリエイト]を選択することで、シグナルを追加できます。
[出力]ウィンドウに、シグナルのデータ型、シグナル名、シグナルが追加されたコンポーネントが表示されます。
同様に、Feeder Proces #2にブール型シグナルFlag2を追加します。
[シグナルをクリエイト]ウィンドウの右下にある[閉じる]を選択し、ウィンドウを閉じます。
各Feeder Processの作業内容を変更するため、[エディタ]グループの[プロセス]を選択します。
FeederとFeeder#2を選択し、プロセスエディターを表示します。
Feeder#2のTransportInとTransportOutの製品変数名を「ProductIn1」に変更します。
Feederの[ステートメント]アイコンを選択します。
[その他のステートメント]から[シグナル送信]を選択します。
シグナル送信ステートメントは、指定したシグナルの値を変更できます。
SendSignalを、TransportInの下にドラッグ＆ドロップします。
[ステートメントプロパティ]ウィンドウの[コンポーネント]と[シグナル]で、シグナルを指定できます。
[値]は、変更後のシグナルの値です。
[コンポーネント]でFeeder Proces #2、[シグナル]でFlag2を選択します。
[値]はTrueです。
Feederがシグナル送信後、Feeder#2から特定の値のシグナルが送信されるまで待機します。
[ステートメント]アイコンを選択します。
[その他のステートメント]から[シグナル待機]を選択します。
シグナル待機ステーメントは、特定の値のシグナルを受信するまで待機できます。
WaitSignalを、SendSignalの下にドラッグ＆ドロップします。
シグナル送信ステートメントと同様に、[ステートメントプロパティ]ウィンドウの[コンポーネント]と[シグナル]で、シグナルを指定できます。
[コンポーネント]は「Feeder Process」、[シグナル]はFlag1です。
[コンディション]でシグナルの値を指定できます。
[コンディション]はTrueです。
[トリガー待機]では、シグナルの値を確認するタイミングを定義します。
チェックが付いている場合、シグナル待機ステートメント実行中、シグナルの値が変化した時のみ、シグナルの値を確認できます。
チェックが付いていない場合、シグナル待機ステートメント実行中にシグナルの値が変化しない場合も、シグナルの値を確認できます。
今回は、チェックを外します。
同様に、Feeder#2にシグナルの待機と、値の送信を実行する処理を追加します。
FeederのSendSignalとWaitSignalを選択し、コピーします。
Feeder#2のTransportInを選択し、貼り付けます。
Feeder#2の場合、Feederからシグナルの値を受信し、Feederへシグナルの値を送信するため、順番を変更します。
WaitSignalをSendSignalの上にドラッグ＆ドロップします。
Feederと、送受信するシグナルが異なるため、変更します。
受信するシグナルは、Feeder Proces #2のFlag2です。
SendSignalを選択します。
送信するシグナルは、Feeder ProcessのFlag1です。
製品を搬送後、シグナルの値を初期値に戻します。
FeederのSendSignalを選択し、コピーします。
FeederのTransportOutを選択し、貼り付けます。
貼り付けたSendSignalを選択します。
変更後の値は、Falseです。
Feeder#2のSendSignalを選択し、コピーします。
Feeder#2のTransportOutを選択し、貼り付けます。
貼り付けたSendSignalを選択します。
変更後の値は、Falseです。
現在の状態では、搬出開始のタイミングが合いません。
AnnaとOttoは、各FeederのTransportOutを受け、移動を開始しています。
移動開始した位置からFeederまでの距離が異なる場合、タイミングは合いません。
AnnaとOttoが、各Feederへ移動完了した時、製品の搬出を開始します。
各Feederに作業者を呼び出します。
Feederの[ステートメント]アイコンを選択します。
[その他のステートメント]から[作業]を選択します。
作業ステートメントは、指定したコントローラーで制御された作業者に、設定された作業動作を実行させることができます。
人には、手を動かす動作が設定されています。
WorkをTransportInの下にドラッグ＆ドロップします。
[ステートメントプロパティ]ウィンドウの[コントローラ]で、作業者を制御しているコントローラーを指定できます。
「Human Transport Controller」を選択します。
[時間ソース]と[プロセス時間]で作業時間を設定できます。
今回は、人を呼び出すのみのため、0.1秒間、作業ステートメントを実行します。
[プロセス時間]に「0.1」と入力します。
同様に、Feeder#2に、作業ステートメントを追加します。
FeederのWorkを選択し、コピーします。
Feeder#2のTransportInを選択し、貼り付けます。
Workを選択します。
[ステートメントプロパティ]ウィンドウの[コントローラ]を、「Human Transport Controller #2」に変更します。
シミュレーションを実行します。
Ottoが先にFeederに到着しますが、Annaが到着するまで待機していることがわかります。
シミュレーションをリセットします。
複数の作業者が、作業場所から製品を搬出開始するタイミングを合わせる方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

複数の作業者が動作するタイミングを合わせよう(4/4)

複数の作業者が一緒に1つの製品を搬送しているような見た目を表現するため、他の作業を割り込ませない方法
https://youtu.be/0rkDhVkrbNg
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_191_p4.zip

複数の作業者が動作するタイミングを合わせる方法について説明します。
本動画では、他の作業が割り込んだ時の対処法を説明します。
付属ファイル「Timing_after3.vcmx」を開きます。
作業場所を追加します。
eカタログの[タイプ別モデル]-[Flow Components]からProcessNodeを配置します。
ダブルクリック、またはドラッグ＆ドロップで配置できます。
ProcessNodeには、デフォルトで、製品を搬入し、搬出する処理が設定されています。
デフォルトの処理を削除し、作業者が手を動かす処理を追加します。
作業者はAnnaです。
[プロセス]タブを開きます。
[エディタ]グループの[プロセス]を選択します。
Process#1を選択します。
TransportInとTransportOutを選択し、右クリック、[削除]を選択します。
[ステートメント]アイコンを選択します。
[その他のステートメント]から[作業]を選択します。
[ステートメントプロパティ]ウィンドウの[コントローラ]で、作業者を制御しているコントローラを指定します。
今回は、Human Transport Controllerです。
[時間ソース]と[プロセス時間]で、作業時間を設定します。
作業時間は5秒です。
シミュレーションを実行します。
Annaは、5秒間作業し、Feederへ移動します。
AnnaはFeederに到着後、製品を搬出する前に、Process#1へ戻ります。
Ottoのみ製品を搬出したことがわかります。
シミュレーションをリセットします。
任意の処理中、他の処理を割り込ませないため、Human Transport ControllerのシグナルReserveResourceと、ReleaseResourceを使用します。
ReserveResourceと、ReleaseResourceの詳細については、動画「ひとつのリソースが続けて作業を行うようにしてみよう」を参照してください。
Feederへの呼び出しから、製品の搬送完了まで、作業者を占有し、製品を搬送完了した時、作業者を解放します。
FeederとFeeder#2のプロセスエディタを表示します。
作業者を占有する作業場所から、Human Transport ControllerのReleaseResourceに、作業場所の名前を入力し、送信します。
Feederの[ステートメント]アイコンを選択します。
[その他のステートメント]から[シグナル送信]を選択します。
追加したSendSignalを、TransportInの下にドラッグ＆ドロップします。
[ステートメントプロパティ]ウィンドウの[コンポーネント]で「Human Transport Controller」を選択します。
[シグナル]は、ReserveResourceです。
ReserveResourceの値に、作業場所のコンポーネント名を入力します。
[値]は、"Feeder Process"です。
文字列型であるため、ダブルクォーテーションマークが必要です。
製品を搬送完了した時、作業者を解放します。
ReleaseResourceの値に、作業場所のコンポーネント名を入力し、送信することで、作業者を解放できます。
SendSignal:"Feeder Process"を選択し、コピーします。
SendSignal:False on Feeder Process#2::Flag2を選択し、貼り付けます。
貼り付けたSendSignalを選択します。
[ステートメントプロパティ]ウィンドウの[シグナル]をReleaseResourceに変更します。
同様に、Feeder#2で、Ottoを占有する処理を追加します。
占有する期間は、OttoをFeeder#2に呼び出す前から、製品を搬送完了した時までです。
Feeder#2の場合、Ottoを占有するため、Human Transport Controller#2を指定します。
送信するシグナルの値は、"Feeder Process#2"です。
シミュレーションを実行します。
Annaは、5秒間作業し、Feederへ移動します。
OttoとAnnaがタイミングを合わせ、製品を搬送していることがわかります。
Process#1での作業が、製品搬送中に割り込むことはありません。
シミュレーションをリセットします。
複数の作業者の動作するタイミングを合わせる方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

複数のコンポーネントを1つにまとめよう

アタッチ機能を使用して、複数のコンポーネントを1つにまとめて、同時に操作する方法
https://youtu.be/lLMX6uwp8G8
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_135.zip

本動画では、アタッチ機能について説明します。
アタッチ機能を使うことで、複数のコンポーネントをまとめて、1つのコンポーネントのように操作することができます。
初めに、「複数のコンポーネントを1つにまとめよう.vcmx」を開きます。
アタッチ機能を使用して、「Printer」と「Table」を1つのコンポーネントにします。
「Printer」をクリックします。
[ホーム]タブ-[階層]-[アタッチ]をクリックします。
"親にアタッチ"ウィンドウが表示されていることを確認し、3Dワールド上の「Table」をクリックします。
これで、「Printer」と「Table」を1つのコンポーネントのように操作できるようになりました。
最初に選択したコンポーネントを子ノード、アタッチをクリック後に選択したコンポーネントを親ノードとして、ツリー構造で管理しています。
今回の場合は、「Printer」が子ノード、「Table」が親ノードになります。
親ノードのコンポーネントをドラッグして移動させると、子ノードのコンポーネントも同じように移動します。
反対に、子ノードのコンポーネントをドラッグして移動させても、親ノードのコンポーネントは移動しません。
子ノードの座標を変更することで、子ノードの原点から親ノードの原点までの位置を確認できます。
「Printer」をクリックし、[コンポーネントプロパティ]ウィンドウから"座標"を"親"に変更すると、座標の値が「Printer」の原点から「Table」の原点までの距離を表示します。
子ノードを選択した状態で[ホーム]タブ-[階層]-[デタッチ]をクリックすると、子ノードと親ノードとのアタッチを解除します。
[デタッチ]は、どのコンポーネントにもアタッチしていない場合は使用できません。
アタッチ機能は、可動部にも使用できます。
「Supporter」をクリックします。
"階層"-"アタッチ"をクリックし、「Positioner」の台座部分を選択してアタッチします。
[マニピュレーション]-[インタラクティブ]をクリックし、「Positioner」の台座部分を動かすと、子ノードである「Supporter」も同じ動きをします。
コンポーネントを複数選択することで、一度に複数のコンポーネントをアタッチすることができます。
「Cylinder」、「Can」、「Ball」、「Bottle」を「Box」の中へ移動します。
「Cylinder」、「Can」、「Ball」、「Bottle」を複数選択します。
[階層]-[アタッチ]をクリックし、「Box」をクリックします。
「Box」を移動させると、「Box」内に配置したコンポーネントが全てアタッチできていることが確認できます。
親ノードのコンポーネントは、子ノードを含めて保存することができます。
「Box」を選択します。
[モデリング]タブ-[コンポーネント]-[名前をつけて保存]をクリックします。
[名前]を"Parts Box"に変更して、"名前を付けて保存"をクリックします。
ファイル形式はvcmxで、任意のフォルダに保存できます。
また、\ドキュメント\MITSUBISHI\Gemini\使用しているバージョン番号\My Models下に保存すると、eカタログウィンドウで表示されるようになります。
今回は、\ドキュメント\MITSUBISHI\Gemini\1.46\My Modelsに、「Parts Box」という名前で保存します。
[ホーム]タブをクリックします。
[eカタログ]ウィンドウ-[マイモデル]をクリックし、先ほど保存した「Parts Box」を3Dワールド上に配置します。
先ほどアタッチした子ノードも保存できたことが確認できます。
以上で、「複数のコンポーネントを1つにまとめよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

複数のコンポーネントを連動して動作させよう

ロボットや装置など、複数のコンポーネントを連動して動作させる方法
https://youtu.be/Rkzw2buxlv0
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_069.zip

本動画では、複数のコンポーネントを連動させる方法について説明します。
今回は、eカタログに登録されている「Generic Articulated Robot」、「Robot Floor Track」、「Workpiece Positioner」の3つを連動するように設定します。
まず初めに、コンポーネントを配置します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Robots]-[Visual Components]から「Generic Articulated Robot」を3Dワールド上にドラッグ&ドロップします。
[タイプ別モデル]-[Robot Positioners]-[Visual Components]から"Robot Floor Track"を3Dワールド上にドラッグ&ドロップします。
[タイプ別モデル]-[Robot Workpiece Positioners]-[Visual Components]から"Workpiece Positioner"を3Dワールド上にドラッグ&ドロップします。
コンポーネントを連動させるには、まず連動させたいコンポーネント同士のインターフェースを接続する必要があります。
接続の仕方には、物理接続する方法と遠隔接続する方法の2種類があります。
物理接続する方法について説明します。
[ホーム]タブ-[マニピュレーション]-[PnP]をクリックします。
[PnP]とは、選択したコンポーネントを別のコンポーネントに近づけてインターフェースを接続する機能です。
この機能が有効な時、物理接続が可能なコンポーネントを選択すると、三角マークが表示されます。
三角マークは他のコンポーネントと接続する際に接点となる場所で、これをインターフェースといいます。
三角マークには、黄色と緑色の2種類があります。
黄色は、そのコンポーネントが他のコンポーネントと接続可能である状態であることを示しています。
緑色は、そのコンポーネントが他のコンポーネントと物理接続している状態であることを示しています。
「Generic Articulated Robot」を選択してドラッグし、「Robot Floor Track」の台座に近づけると、緑色の矢印が表示されます。
この緑色の矢印は、ドラッグしたコンポーネントが近づけたコンポーネントと物理接続できる場合に表示されます。
この状態でドロップすると、自動的に接続され、三角マークが緑色に変化します。
「Robot Floor Track」を選択して移動させると、「Generic Articulated Robot」も追従して移動します。
また、[マニピュレーション]-[インタラクティブ]を選択している状態で「Robot Floor Track」の台座を選択しドラッグした場合でも、「Generic Articulated Robot」は追従して移動します。
[マニピュレーション]-[PnP]を選択している状態で、「Generic Articulated Robot」を選択し、ドラッグして「Robot Floor Track」から距離を離すと物理接続は解除されます。
次に、遠隔接続する方法について説明をします。
[接続]-[インターフェース]をクリックします。
3Dワールド上のコンポーネントを選択すると、遠隔接続ができるインターフェースが表示されます。
3Dワールド上の「Workpiece Positioner」を選択します。
"Workpiece Positioner"は、パーツを表面板に取り付け、ロボットの動きによってパーツを動かしたいときに使用します。
今回は、パーツは取り付けずに使用します。
"RobotInterface"と"Connect Workpiece Positioner"を接続します。
3Dワールド上のインターフェース名の横にある丸印を接続先のインターフェースへドラッグする、または[インターフェースに接続]ウィンドウから"コンポーネント"に接続元のコンポーネントを設定し、"このリストからインターフェースに接続"で接続先を選択することで接続ができます。
また、物理接続で使用するインターフェースを使って、遠隔接続することができます。
[インターフェースに接続]ウィンドウから、"コンポーネント"を「Generic Articulated Robot」に変更します。
[インターフェースに接続]ウィンドウ下部にある"非抽象インターフェースを表示"にチェックを入れると、物理接続で使用するインターフェースが表示されます。
「Workpiece Positioner」と接続した時と同じ手順で、「Generic Articulated Robot」の"RobotPositioner"と「Robot Floor Track」の"RobotInterface"を接続します。
[接続]-[インターフェース]をクリックします。
「Robot Floor Track」を選択して移動させると、「Generic Articulated Robot」も追従して移動します。
また、[マニピュレーション]-[インタラクティブ]を選択している状態で、「Robot Floor Track」の台座を選択しドラッグした場合でも、「Generic Articulated Robot」は追従して移動します。
動作を確認したら、再度[マニピュレーション]-[PnP]をクリックし、「Generic Articulated Robot」をドラッグして「Robot Floor Track」の台座に近づけ、接続します。
ここまでの設定で、3つのコンポーネントが連動するようになりました。
最後に、動作内容の設定を行います。
[プログラム]タブ-[ジョグ]をクリックして、3Dワールド上の「Generic Articulated Robot」を選択します。
"ジョグ"ウィンドウの"ジョイント"では「Generic Articulated Robot」の各部位の位置や向きが設定できます。
"Workpiece Positioner"では、「Workpiece Positioner」のアームの位置や台座の向きが設定できます。
"Robot Floor Track"では、「Robot Floor Track」の台座の位置が設定できます。
各値を変更した後に、[プログラムエディタ]ウィンドウ-"各軸補間ステートメント"をクリックします。
このステートメントは、シミュレーションを再生した時に、ロボットを定義した位置へ移動させるコマンドです。
"ジョグ"ウィンドウから各値を変更して、同様の手順で[プログラムエディタ]ウィンドウにステートメントを追加します。
追加ができたら、"リセット"をクリックしてコンポーネントを初期位置に戻し、シミュレーションを再生します。
「Generic Articulated Robot」の設定のみで、3つのコンポーネントがそれぞれ動作するようになりました。
以上で、「複数のコンポーネントを連動して動作させよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

複数のパーツを使用して製品を組み立てよう

プロセスモデリングでのアセンブリを組み立てる設定方法
（アセンブリを取得、アセンブリプロパティを取得）
https://youtu.be/hB13EaRKj48
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_062.zip

本動画では、複数のパーツを使用して製品を組み立て、アセンブリステートメントの使い方について説明します。
シミュレーション中にアセンブリに関する処理を行うステートメントをまとめてアセンブリステートメントといいます。
まず初めに、アセンブリの定義で使用するコンポーネントを製品タイプエディタに登録します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Products and Containers]から"Piston Head"、"Piston Rod"、"Piston Shaft"を3Dワールド上にドラッグ&ドロップします。
[プロセス]タブ-[エディタ]-[製品]をクリックします。
[製品タイプエディタ]ウィンドウ-[製品の定義]-[フローグループを追加]をクリックします。
続けて、"製品タイプを追加"を3回クリックし、"製品タイプ番号1-3"を追加します。
"フローグループ番号1"を選択し、名前を「PistonParts」に変更します。
"製品タイプ番号1"を選択し、[Name]を"Piston Head"に変更、"Pick Component from 3D world"をクリックして3Dワールド上の「Piston Head」をクリックします。
同様の手順で、"製品タイプ番号2"と"製品タイプ番号3"を"Piston Rod"と"Piston Shaft"に変更します。
次に、製品タイプエディタにアセンブリとアセンブリステップを追加します。
[製品タイプエディタ]ウィンドウ-[製品の定義]-[フローグループを追加]をクリックします。
"フローグループ番号1"の名前を「Piston」に変更します。
"Piston"を選択した状態で"製品の定義"-"アセンブリを追加"をクリックします。
"アセンブリ番号1"を選択し、[名前]を"PistonAssembly"に変更します。
"PistonAssembly"横の十字アイコンをクリックして、展開します。
"ステップ番号1"を選択し、[名前]を"Head Step"に変更します。
[製品タイプエディタ]ウィンドウ-"Head Step"を右クリックし、"ステップを追加"をクリックします。
追加されたアセンブリステップの[名前]を"Rod Step"に変更します。
同様の手順で、"Rod Step"下に"Shaft Step"を追加します。
追加したアセンブリステップに、生成するパーツを割り当てます。
[製品タイプエディタ]ウィンドウ-"Head Step"をクリックし、"アセンブリエディタを開く(ペンアイコン)"をクリックします。
アセンブリエディタ上の「Head Step-アセンブリスロット(黄色のボックス)」を選択します。
[プロパティ]ウィンドウから"既定の製品タイプ"を"Piston Head"に変更します。
アセンブリエディタ上の"Head Step-アセンブリスロット"が黄色のボックスから"Piston Head"に変化します。
同様の手順で、「Rod Step-アセンブリスロット」の"既定の製品タイプ"を"Piston Rod"、「Shaft Step-アセンブリスロット」の"既定の製品タイプ"を"Piston Shaft"を設定します。
これで、アセンブリの定義ができました。
アセンブリは製品タイプエディタに定義されているため、Feederで生成できます。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Conveyors]から"Conveyor"を3Dワールド上にドラッグ&ドロップします。
[タイプ別モデル]-[PM Flow Components]から"Feeder"を3Dワールド上にドラッグ&ドロップします。
[マニピュレーション]-[PnP]を選択した状態で「Feeder」を「Conveyor」に近づけ、接続します。
[コンポーネントプロパティ]ウィンドウ-[ProductCreator]タブから"パーツ"を"PistonAssembly"に変更します。
シミュレーションを再生します。
"PistonAssembly"が生成されます。
アセンブリステップを設定する時に、アセンブリスロットの"既定の製品タイプ"が"Null"の場合、そのアセンブリスロットには何も生成されません。
[製品タイプエディタ]ウィンドウ-"Rod Step"を選択して、アセンブリエディタを開く"をクリックします。
「Rod Step-アセンブリスロット」を選択して、[プロパティ]ウィンドウから"既定の製品タイプ"を"Null"に変更します。
アセンブリエディタを閉じてシミュレーションを再生します。
設定を変更した"Rod Step"は生成されなくなりました。
[製品タイプエディタ]-"Rod Step"を選択してアセンブリエディタを開き、「Rod Step-アセンブリスロット」を選択して[プロパティ]ウィンドウから"既定の製品タイプ"を"Piston Rod"に戻します。
アセンブリは、他のアセンブリのアセンブリスロットの"既定の製品タイプ"に設定できます。
パーツとアセンブリを追加して定義します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[Products and Containers]から"engine_block"を3Dワールドにドラッグ&ドロップします。
[製品タイプエディタ]ウィンドウ-"フローグループ番号1"を選択して名前を"Engine Group"に変更します。
"Engine Group"を選択した状態で"製品を定義"から"製品タイプを追加"と"アセンブリを追加"をクリックします。
"VC_Cylinder"は使用しないため、削除します。
追加された"製品タイプ番号1"を選択して[Name]を"Engine"に変更し、"Pick Component from 3D world"クリックして3Dワールド上の「engine_block」を選択します。
追加された"アセンブリ番号1"を選択し[名前]を"EngineAssembly"に変更します。
"EngineAssembly"-"ステップ番号1"を選択し[名前]を"Engine Block"に変更します。
"Engine Block"を右クリックし、"ステップを追加"をクリックします。
追加された"ステップ番号1"を選択し、[名前]を"Pistons"に変更します。
"EngineAssembly"の各アセンブリステップの設定を行います。
[製品タイプエディタ]ウィンドウ-"Engine Block"をクリックし、"アセンブリエディタを開く"をクリックします。
「Engine Block-アセンブリスロット」を選択し、[プロパティ]ウィンドウから"既定の製品タイプ"を"Engine"に変更します。
"Pistons"をクリックします。
アセンブリスロットのサイズを、今回割り当てる"Piston Assembly"の大きさに合うように変更します。
「Pistons-アセンブリスロット」を選択し、"既定の境界線の寸法"の"Z"を"225"に変更します。
"既定の製品タイプ"を"PistonAssembly"に変更します。
アセンブリスロットの"既定の製品タイプ"にアセンブリを設定した場合、アセンブリエディタ上での表示は"Null"と同じになります。
スナップなどを使用して、「Pistons-アセンブリスロット」を「Engine Block-アセンブリスロット」内に配置します。
アセンブリスロット1つにつき、パーツが1つ割り当てられます。
配置するパーツを増やす場合、アセンブリスロットを追加する必要があります。
「Pistons-アセンブリスロット」を選択した状態で、アセンブリエディタ上のツールバーの"スロットを追加(9つの四角形)"をクリックします。
今回は、「Engine Block-アセンブリスロット」内に4つずつ"PistonAssembly"を配置するように変更します。
"スロットパターンを選択"に"テンプレートから"-"Linear"、"パターンプロパティ"で横に4つ画面のように配置できたら"適用"をクリックします。
生成されたアセンブリスロットを複数選択で全て選択して位置を調整します。
位置を調整したら、[選択]をクリックして「Pistons-アセンブリスロット」を全て選択し、コピー&ペーストして反対側にも配置します。
位置を調整出来たらアセンブリエディタを閉じます。
「Feeder」をクリックし、[コンポーネントプロパティ]ウィンドウ-[ProductCreator]タブから"パーツ"を"EngineAssembly"に変更します。
シミュレーションを再生します。
"Engine Block"の中に"PistonAssembly"が配置された"EngineAssembly"が生成されます。
アセンブリは、プロセスの"製品作成"ステートメントでも生成できます。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Flow Components]から"Process Node"を3Dワールドにドラッグ&ドロップします。
[マニピュレーション]-[PnP]を選択した状態で「Process Node」をドラッグして「Conveyor」に近づけ、接続します。
「Conveyor」と接続していた「Feeder」は削除します。
[エディタ]-[プロセス]を選択し、"Process #1"をクリックします。
"ステートメント"-"製品作成"をクリックします。
"TransportIn:~"を削除し、追加された"Create:~"を先頭に移動します。
"Create:~"を選択し、[ステートメントプロパティ]ウィンドウから"製品タイプ"を"PistonAssembly"、[製品変数名]を"ProductIn"に変更します。
"TransportOut:~"を選択します。
[ステートメントプロパティ]ウィンドウから[目的地]を"コンポーネントコンテナへ"に変更します。
シミュレーションを再生すると、"PistonAssembly"が生成されます。
"Create"ステートメントの"製品タイプ"にアセンブ設定すると、[ステートメントプロパティ]にアセンブリステップの設定をするプロパティが表示されます。
"アセンブリステップ"は、生成するアセンブリステップを設定します。
"アセンブリステップ"を"Head Step"のみにし、シミュレーションを再生すると、"Head Step"のみの"PistonAssembly"が生成されます。
"子ステップを含む"にチェックを入れると、製品を生成する時に、生成するアセンブリステップの子ステップも自動的に生成されるようになります。
"子ステップを含む"にチェックを入れ、シミュレーションを再生します。
"アセンブリステップ"は"Head Step"のみですが、"Head Step"の子ステップである"Rod Step"と"Shaft Step"も生成されます。
"アセンブリステップ"に"Rod Step"と"Shaft Step"を追加し、"子ステップを含む"のチェックを外してシミュレーションを再生します。
製品が生成される際は、親ステップのアセンブリステップから順に適用されます。
"PistonAssembly"の場合、まず"Head Step"が生成され"Rod Step"、"Shaft Step"と順に生成します。
その後、"Shaft Step"は"Rod Step"に、"Rod Step"は"Head Step"にアタッチして1つの製品になります。
この時、アセンブリステップが一部生成されなかった場合、生成されたアセンブリステップは生成されなかったアセンブリステップを飛ばしてアタッチします。
"アセンブリステップ"の"Rod Step"を削除して、シミュレーションを再生します。
"Shaft Step"は、生成されなかった"Rod Step"の代わりに"Head Step"にアタッチします。
"アセンブリからのオフセットを維持"にチェックを入れると、アセンブリスロットを単体で生成した時に、アセンブリスロットで設定したオフセットが反映されるようになります。
"製品タイプエディタ"-"Rod Step"を選択して、"アセンエブリディタを開く"をクリックします。
「Rod Step-アセンブリスロット」を選択し、オフセットを設定します。
オフセットを設定したら、"Process #1"をクリックします。
"Create:~"を選択し、[ステートメントプロパティ]ウィンドウから"アセンブリステップ"を"Rod Step"のみにします。
"アセンブリからのオフセットを維持"にチェックを入れずにシミュレーションを再生します。
その後、"アセンブリからのオフセットを維持"にチェックを入れシミュレーションを再生します。
アセンブリスロットで設定したオフセットが反映されることが確認できます。
「Rod Step-アセンブリスロット」のオフセットを元に戻します。
"ステートメント"にあるアセンブリステートメントについて説明します。
"アセンブリを取得"ステートメントは、アセンブリステップの情報を取得し変数に保存するステートメントです。
情報には、アセンブリスロットに割り当てられたパーツや、そのパーツの配置位置や配置のする時の順番などが含まれています。
輸送された製品を分解する、または輸送されたパーツを組み合わせて製品を作成する時などに使用します。
"アセンブリデータソース"は、アセンブリステップの情報の取得元を設定します。
"アセンブリインスタンス"と"アセンブリ製品タイプ"の2種類が存在し、それぞれで設定するプロパティが異なります。
まず、"アセンブリインスタンス"について説明します。
"アセンブリインスタンス"は、プロセスへ輸送された製品からアセンブリステップの情報を取得する設定です。
"アセンブリ変数名"には製品変数名を設定し、どの製品を対象とするかを指定します。
"アセンブリステップ"は、対象となる製品の、どのアセンブリステップの情報を取得するかを指定します。
"子ステップを含む"にチェックを入れると、アセンブリステップから情報を取得する時に、そのアセンブリステップの子ステップの情報も取得できます。
"リストとしてリターン"にチェックを入れると、アセンブリステップの情報を取得する時に、製品インスタンスのリストとして取得できます。
"逆リスト"にチェックを入れると、アセンブリステップの情報をリストとして取得した時に、並び順を逆順にすることができます。
"変数名リターン"は、情報を保存する変数の名称です。
"アセンブリデータソース"に"アセンブリインスタンス"を設定した時のプロパティの説明は以上になります。
次に、"アセンブリ製品タイプ"について説明します。
"アセンブリ製品タイプ"は、製品タイプエディタで定義されているアセンブリからアセンブリステップの情報を取得する設定です。
"アセンブリ"には、製品タイプエディタのどのアセンブリを対象とするかを設定します。
"アセンブリステップ"は、"アセンブリインスタンス"の同様に、どのアセンブリステップの情報を取得するかを設定します。
ここで選択できるアセンブリステップは、製品タイプエディタに設定した"アセンブリ"に定義されているアセンブリステップのみです。
今回の場合、"PistonAssembly"に定義されているアセンブリステップが設定できます。
"子ステップを含む"と"変数名リターン"は、"アセンブリインスタンス"と同じです。
"アセンブリデータソース"に"アセンブリ製品タイプ"を設定した時のプロパティの説明は以上になります。
"構築"ステートメントは、プロセス内に流れてきたパーツを使用して製品を組み立てるステートメントです。
"アセンブリ命令変数名"は、製品を組み立てる際にどの情報を使用するかを設定します。
[製品変数名]は、製品を組み立てる際に使用するパーツを設定します。
"アセンブリ時間"は、製品を組み立てるまでにかかる時間を設定します。
"削除受け入れ"は、製品を組み立てるために使用したパーツの情報を、製品変数から削除するかを設定します。
"変数名リターン"は、組み立てた製品の変数名を設定します。
このステートメントで使用するアセンブリ命令変数には、構築するときの組み立て順序の情報が含まれています。
そのため、パーツがどのような順番で流れてきても製品を組み立てることができます。
"アセンブリを取得"ステートメントと"構築"ステートメントを追加して、シミュレーション中に"Piston Assembly"を作成します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Flow Components]から"Feeder Process"を3Dワールド上にドラッグ&ドロップします。
コピー&ペーストで合計3つに増やし、[コンポーネントプロパティ]-[ProductCreator]タブの"パーツ"をそれぞれ"Piston Head"、"Piston Rod"、"Piston Shaft"に変更します。
[プロセス]タブ-[エディタ]-[フロー]を選択し、3Dワールド上の「Feeder」のプロセスラベル-"Process #1"のプロセスラベルと順にクリックします。
次に、"Process #1"を追記します。
"TransportIn:~"を選択します。
[ステートメントプロパティ]ウィンドウから"全製品タイプを受け入れ"のチェックを外し、"受け入れられた製品タイプ"を"Piston Head"のみに設定します。
"TransportIn:~"をコピー&ペーストで2つ追加し、それぞれの"受け入れられた製品タイプ"を"Piston Rod"のみと"Piston Shaft"のみにします。
"Create:~"を削除します。
これで、アセンブリを作成するために必要なパーツを受け取るプロセスが設定できました。
3つめの"TransportIn:~"の下に、"アセンブリを取得"ステートメントを追加します。
"GetAssembly:~"を選択し、"アセンブリデータソース"を"アセンブリ製品タイプ"、"アセンブリ"を"Piston Assembly"に変更します。
"アセンブリステップ"が表示され、"Head Step"、"Rod Step"、"Shaft Step"が設定されていることが確認できます。
これで、製品タイプエディタに登録されている"Piston Assembly"の各アセンブリステップの情報が"AssemblyOrder"に保存されます。
"GetAssembly:~"の下に、"構築"ステートメントを追加します。
このステートメントが実行されると、"ProductIn"を使って"AssemblyOrder"の情報をもとに製品を作成し、"Assembly"という名前の製品ができます。
今回の場合、"Piston Head"、"Piston Rod"、"Piston Shaft"の3つのパーツを使って、"Piston Assembly"のアセンブリステップの情報をもとに製品を作成します。
最後に、"TransportOut:~"を選択し、[ステートメントプロパティ]ウィンドウから[製品変数名]を"Assembly"に変更します。
シミュレーションを再生します。
輸送されたパーツが"Process #1"で1つの製品になります。
また、"Process #1"の"TransportIn:~"の順番を入れ替えた場合も、問題なく製品が作成されます。
他のステートメントについて説明します。
"アセンブリプロパティを取得"ステートメントは、アセンブリステップの情報が保存されている"アセンブリ命令変数"使って、アセンブリステップのステッププロパティ値を取得し、ステートメントで使用できる変数に保存するステートメントです。
ステッププロパティを追加して、実際に"アセンブリプロパティを取得"ステートメントを使用します。
まず、ステッププロパティを追加します。
[製品タイプエディタ]-"HeadStep"-"ステッププロパティ"を右クリックし、"プロパティを追加"をクリックします。
[プロパティ]ウィンドウから[名前]を"Interval"、"Type"を"Int32"、"Default Value"を"10"に変更します。
ここまでで、ステッププロパティを追加できました。
次に、ステートメントを追加します。
"Process #1"の"GetAssembly:~"を選択し、"ステートメント"-"アセンブリプロパティを取得"をクリックします。
追加された"GetAssemblyProperty"を選択し、[ステートメントプロパティ]から"プロパティ名"を"Interval"、"出力変数名"を"Interval"に変更します。
ここまでで、ステッププロパティを取得して変数に保存できるようになりました。
最後に、保存した変数を使用するステートメントを追加します。
"Construct:~"を選択した状態で"ステートメント"-"ディレイ"をクリックします。
追加された"Delay:~"を選択し、[ステートメントプロパティ]から"時間ソース"を"数式"、"数式"を"Interval"に変更します。
シミュレーションを再生します。
アセンブリステップに設定したステッププロパティを取得し、その値分アセンブリ生成後にディレイするようになります。
"アセンブリを確認"ステートメントは、アセンブリ変数とアセンブリ命令変数の比較をし、その結果を変数に保存します。
変数はBoolean型であり、一致していればTrue、そうでなければFalseとなります。
実際に"アセンブリを確認"ステートメントを使って、輸送された製品と生成した製品の比較を行うようにします。
まず、製品を生成する「Feeder」を追加します。
[eカタログ]ウィンドウ-[タイプ別モデル]-[PM Flow Components]から"Feeder"を3Dワールド上にドラッグ&ドロップし、PnPで接続します。
追加した「Feeder」を選択し、[コンポーネントプロパティ]-[ProductCreator]から"パーツ"を"PistonAssembly"、"制限"を"1"に変更します。
次に、"Process #1"に輸送された製品の情報を取得するステートメントを追加します。
"Process #1"をクリックし、"ステートメント"-"トランスポートイン"をクリックします。
追加された"TransportIn:~"をクリックし、[ステートメントプロパティ]ウィンドウから"ソース"を"コンポーネントコンテナから"に変更した後、先頭へ移動します。
先頭へ移動した"TransportIn:Any Product~"を選択した状態で、"アセンブリを取得"ステートメント、"トランスポートアウト"ステートメントと順にクリックします。
追加した"GetAssembly:~"を選択し、[ステートメントプロパティ]から"アセンブリデータソース"を"アセンブリインスタンス"、"アセンブリ変数名"を"ProductIn"、"アセンブリステップ"を"最後のステップ(製品あり)"、"変数名リターン"を"Create"に変更します。
追加した"TransportOut:~"を選択し、[ステートメントプロパティ]から[目的地]を"コンポーネントコンテナへ"に変更します。
ここまでで、輸送されたアセンブリから情報を取得できるようになりました。
最後に、"アセンブリを確認"ステートメントとその内容で出力を変えるステートメントを追加します。
"Delay~"を選択し、"ステートメント"-"アセンブリを確認"をクリックします。
追加された"CheckAssembly:~"を選択し、[ステートメントプロパティ]から"アセンブリ命令変数"を"Create"に変更します。
"CheckAssembly"を選択した状態で"ステートメント"-"IF"をクリックします。
追加された"If:~"を選択し、[ステートメントプロパティ]から[コンディション]を"AssemblyReady"に変更します。
"Then"と"Else"にそれぞれ"ステートメント"-"プリント"を追加し、[ステートメントプロパティ]から"メッセージ"を設定します。
これで、輸送された製品の情報と、"PistonAssembly"を生成するために取得した製品タイプエディタのアセンブリの情報を比較して、その結果に応じてメッセージを出力できるようになりました。
シミュレーションを再生します。
情報が一致するため[出力]ウィンドウには、"Then"で設定したメッセージが出力されます。
「Feeder」をクリックし、[コンポーネントプロパティ]-[ProductCreator]から"パーツ"を"EngineAssembly"に変更して再度シミュレーションを再生します。
この場合は情報が不一致なため、"Else"のメッセージが出力されます。
以上で、「複数のパーツを使用して製品を組み立てよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

録画する時のカメラの視点を設定しよう

録画する時のカメラの視点をカメラアニメーターで設定する方法（関連動画：録画する時のカメラの視点をPythonで設定しよう）
https://youtu.be/1MXvKErHJIA
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_090.zip

本動画では、カメラアニメーターを使って、録画する時のカメラの視点を設定する方法について説明します。
まず初めに、レイアウトを用意します。
今回は、eカタログに登録されているレイアウトを使用します。
[eカタログ]ウィンドウ-[タイプ別モデル]-"Layouts"から"Final Palletizing and Packaging PM"をダブルクリックします。
これで、レイアウトを配置できました。
カメラアニメーターについて説明します。
カメラアニメーターとは、ビューと時間を設定して、シミュレーション中に設定したビューへカメラ移動するようにする機能です。
この機能を使って、録画する時のカメラの視点を設定します。
[Camera]-[カメラアニメーター]をクリックします。
"カメラアニメーター"のプロパティについて説明します。
"シミュレーション時間"と"相対的時間"は、"時間"の定義の仕方を設定します。
詳細は、"時間"の説明の時に併せて行います。
"ビュー"は、カメラ移動が完了した時の視点を設定します。
視点は、"3Dワールドツールバー"-"ビューエディタ"に登録されているビューを選択することで設定します。
また、"(新規カメラビューを追加)クリックすると、現在の視点を新規ビューとして追加します。
今回は、レイアウトに登録されている4つのビューを使用します。
"時間"は、"ビュー"にカメラ移動が完了するタイミングを設定します。
"シミュレーション時間"を選択している場合、シミュレーションの再生時間を基準として、時間を設定します。
"シミュレーション時間"を選択して20秒ごとにカメラ移動するように設定する場合、"View"の"時間"は"0:00:00"、"View2"の"時間"は"0:00:20"、"View3"の"時間"は"0:00:40"、"View4"の"時間"は"0:01:00"と設定します。
"相対的時間"を選択している場合、直前のビューにカメラ移動が完了したタイミングを基準として、"時間"を設定します。
"相対的時間"を選択して20秒ごとにカメラ移動するように設定する場合、"View"の"時間"は"0:00:00"、"View2"、"View3"、"View4"の"時間"は"0:00:20"と設定します。
"円弧"は、カメラ移動の補間方法について設定します。
チェックをつけた場合は円弧補間、外した場合は線形補間でカメラ移動を補間します。
ビューを切り替える時に、円弧補間の場合は移動先のビューの中心に回り込むように移動します。
線形補間の場合は、移動先のビューの中心を通過するように直線的に移動します。
今回は、"シミュレーション時間"を選択して、"0:00:00"の時に"View"、"0:00:10"の時に"View2"、"0:00:30"の時に"View3"、"0:01:00"の時に"View4"の視点になるように設定します。
一番右列のアイコンが[+(ビューステートメントを追加)]アイコンの場合、その行の設定は完了していません。
"ビューステートメントを追加"をクリックする、または"ビュー"か"時間"を選択した状態でEnterキーを押下して、設定を完了してください。
シミュレーションを再生します。
シミュレーション時間に応じて自動的にカメラ移動します。
カメラアニメーターを設定後にカメラ移動を無効にする場合、"カメラアニメーター"ウィンドウの"カメラアニメーションが有効です"のチェックを外します。
カメラアニメーターで設定したカメラ移動は、エクスポートした動画にも反映されます。
シミュレーション中の様子を録画して、Visual Components Experienceという動画再生アプリケーションで確認します。
"シミュレーションコントロール"パネル-"アニメーションにエクスポート"をクリックします。
"アニメーションにエクスポート"ウィンドウ-"録画を開始"をクリックします。
1分程度再生したら、"停止"をクリックします。
保存したファイルを、Visual Components Experienceで開きます。
Visual Components Experienceで動画ファイ開くと、自動的に再生されます。
画面左下の歯車アイコンをクリックし、"Use recorded camera"にチェックを入れると、先ほど設定したカメラ移動が反映されることが確認できます。
以上で、「録画する時のカメラの視点を設定しよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

輸送する製品を制限してみよう

Gemini 1.48以降の機能です。
ラインシミュレーションで搬送する製品の種類を製品フィルター機能で制限する方法
https://youtu.be/agSPObdhhfs
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_123.zip

本動画では、製品を輸送する時に、輸送する製品を特定の製品のみに制限する方法について説明します。
製品フィルター機能を使うことで、特定の条件を満たした製品のみを輸送することができます。
この機能はバージョン1.48以降で使用できます。
まずはじめに、「輸送する製品を制限してみよう.vcmx」を開きます。
シミュレーションを再生します。
このレイアウトでは、2つのフローグループの中に4つの異なる製品タイプが定義されています。
製品には、製品プロパティとコンポーネントプロパティがそれぞれ設定されています。
製品はFeederでランダムに生成され、Bufferを経由してSinkプロセスに輸送されます。
まず、このレイアウトに製品フィルター機能を設定します。
製品フィルター機能は、製品を制限する機能です。条件を設定して、それを満たす製品のみを搬入する時に使用します。
製品フィルター機能について説明します。
製品フィルター機能は、プロセスへ輸送する製品を制限する機能です。
条件を設定して、それを満たす製品のみを搬入する時に使用します。
フィルタは、"トランスポートイン"や"トランスポートパターンイン"など、製品を搬入するプロセスルーチンステートメントや、アセンブリスロットで設定できます。
今回は、トランスポートインのフィルタを使用します。
詳細は、"ヘルプ"の"製品のフィルタ処理"ページから確認できます。
Sinkプロセスの"トランスポートイン"ステートメントに、製品フィルター機能を設定します。
まず、[プロセス]タブ-[エディタ]-[プロセス]を選択し、Sinkをクリックします。
Sinkプロセスの中にある"トランスポートイン"ステートメントを選択します。
製品フィルター機能は、[ステートメントプロパティ]ウィンドウの"製品フィルタ"から設定ができます。
初期設定ではフィルタ条件が設定されていないため、全製品を搬入していました。
"製品フィルターを追加"をクリックすることで、フィルタを追加して設定できます。
各製品フィルターについて説明します。
1つ目は、"製品タイプ"フィルタです。
このフィルタは、製品タイプ、またはフローグループでフィルタをかけて、搬入する製品を制限します。
"製品タイプ"フィルタを追加して、設定を行います。画面では、"使用可能な製品タイプ"にBox1を設定しました。
シミュレーションを再生します。
Box1のみが、Sinkへ輸送されます。
次に、"使用可能なフローグループ"で"フローグループ番号2"を選択して、シミュレーションを再生します。
Box1に加え、フローグループ番号2に属するBox4も、Sinkへ輸送されます。
"製品タイプ"フィルタについての説明は、以上になります。
2つ目は、"製品プロパティ"フィルタです。
このフィルタは、製品に設定する製品プロパティの値でフィルタをかけて、搬入する製品を制限します。
"製品プロパティ"フィルタを追加して、設定を行います。
画面では、"ターゲットプロパティ"に"SKU"と設定し、"比較値"に"123"を設定しました。
比較演算子はデフォルトのままで、イコールとしておきます。
先ほど設定した"製品タイプ"フィルタのチェックボックスを外して、フィルタを無効にしておきます。
シミュレーションを再生します。製品プロパティ"SKU"が存在し、その値が"123"であるBox1とBox4がSinkへ輸送されます。
"比較値"を"345"に変更して、シミュレーションを再生します。
この場合、製品プロパティSKUが存在し、その値が345であるBox3のみがSinkへ輸送されます。
"製品プロパティ"フィルタの説明は、以上になります。
3つ目は、"数式"フィルタです。
このフィルタは、条件式を満たすかどうかでフィルタをかけ、製品の搬入を制限します。
条件式の演算対象には、製品に設定されたプロパティや、フィルタを含むステートメントが配置されているプロセスの変数を使用することができます。
Sinkプロセスに変数を設定し、その変数を使って"数式"フィルタを設定します。
Sinkプロセスの[ルーチンプロパティ]ウィンドウを開きます。
"新規変数を追加"-"整数変数"をクリックし、整数変数を追加します。
"変数名"は"Integer_1"から"Height"へ変更します。
次に、Sinkプロセスに"変数を割り当てる"ステートメントを追加し、"トランスポートイン"ステートメントの上にドラッグアンドドロップで移動します。
"変数を割り当てる"ステートメントの[ステートメントプロパティ]ウィンドウから、"ターゲットプロパティ"に"Height"、"数式値"に"400"と入力します。
次に、"トランスポートイン"ステートメントをクリックし、[ステートメントプロパティ]ウィンドウ-"製品フィルタ"のフィルタ追加ボタンをクリックして、"数式"フィルタを追加します。
数式フィルタの設定欄、"数式のプロパティ"に、Product.Component.Height_Z > Heightと入力します。
Product.Component.Height_Zには、輸送する製品のHeight_Zプロパティが入ります。
また、Heightには、Sinkプロセス上で設定したHeight変数が入ります。
つまり、製品のHeight_ZプロパティがHeight変数の値である400より大きければ、その製品を受け入れるようになります。
先ほど追加した"製品プロパティ"フィルタを無効にします。
シミュレーションを再生します。
Height_Z が400以上であるBox2、Box3、Box4がSinkへ輸送されます。
"数式"フィルタの説明は以上になります。
4つ目のフィルタは、"特定の製品"フィルタです。
このフィルタは、製品インスタンスでフィルタをかけて、製品の搬入を制限します。
製品インスタンスとは、シミュレーション再生中に作られて、実際に移動する製品のことです。
このフィルタは、別のレイアウトで動作を確認します。
「輸送する製品を制限してみよう_2.vcmx」を開きます。
シミュレーションを再生します。
製品はFeederプロセスからManualProcessへ移動後、一度CMM プロセスに移動します。
その後、もう一度ManualProcessへ移動し、Sinkプロセスへ搬出されます。
[プロセス]タブ-[エディタ]-[プロセス]をクリックし、ManualProcessをクリックします。
2つ目の"トランスポートイン"ステートメントで、"特定の製品"フィルタを設定しています。
[製品変数名]には"ProductIn"を設定しています。
この"ProductIn"は、1つ目のTransportInで搬入した製品である"ProductIn"と同じ製品インスタンスを持つルーチンプロパティです。
シミュレーション再生中に[ルーチンプロパティ]ウィンドウで確認できます。
つまり、2つ目の"トランスポートイン"ステートメントは、1つ目のトランスポートインで搬入した製品の製品インスタンスと一致する製品のみを受け入れ可能状態にしています。
そのため、2つ目の"トランスポートイン"ステートメントでは、CMMから戻ってきたBoxのみを搬入しています。
"特定の製品"フィルタの説明は、以上になります。
ここまでで紹介した4種類のフィルタは、組み合わせて使うこともできます。
もう一度、「輸送する製品を制限してみよう.vcmx」を開きます。
[プロセス]タブ-[エディタ]-[プロセス]を選択後、Sinkをクリックし、Sinkプロセスの中にある"トランスポートイン"ステートメントを選択します。
有効にしたいフィルタを有効にします。画面では、"数式"フィルタと"製品タイプ"フィルタを有効にしました。
また、複数のフィルタを有効にした時、"および/または"のリストボックスが表示されます。
"および"の場合、前後のフィルタのどちらも満たした製品のみ搬入します。
シミュレーションを再生します。
この場合、"製品タイプ"フィルタと"数式"フィルタの両方を満たしたBox4のみ輸送されます。
"または"の場合、前後のフィルタのいずれかを満たした製品のみ搬入します。
"または"に変更して、シミュレーションを再生します。
"製品タイプ"フィルターを満たすBox1、"数式"フィルターを満たすBox2、Box3、"製品タイプ"フィルターと"数式"フィルターを満たすBox4が輸送されるようになりました。
以上で、「輸送する製品を制限してみよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

2軸回転ポジショナを作成し、ロボットと接続しよう(1/2)

オリジナルの2軸回転ポジショナを作る方法（3DCADファイルをインポート、可動部を分割）
https://youtu.be/BFb5lJuUmUw
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_117_p1.zip

2軸回転ポジショナを作成し、ロボットと接続する方法を説明します。
インポートしたモデルから、2軸回転ポジショナを作成します。
動画内で使用するロボットツールの3DCADファイルをダウンロードします。
ファイル名は、[CompactPositionerAssembly.stp]です。
[モデリング]タブを開きます。
[インポート]-[ジオメトリ]を選択します。
ダウンロードしたファイルを開きます。
[モデルをインポート]ウィンドウの[テッセレーションの品質]を中位品質にします。
テッセレーションの品質はポリゴンの分割数を増減できます。
テッセレーションを高くするほど、ポリゴンの分割数が増え、滑らかになります。
分析ボタンをクリックすると、インポートするモデルの情報が表示されます。
三角形の数は6706個あるということがわかります。
今回は適切な数のため、中位品質に確定します。
[フィーチャツリー]で[完全]を選択し、CADのツリー構造をベースにフィーチャツリーを作成します。
[ジオメトリを整理]で[マテリアルによる]を選択し、1つのメッシュにマテリアルを定義するためのジオメトリセットを作成します。
ジオメトリセットは、フィーチャツリーの各ジオメトリの中に含まれるジオメトリのまとまりです。
[上軸]は、[+Z]を選択します。
[インポート]を選択し、ポジショナの3DCADをインポートします。
ポジショナの原点が、3Dワールド上の原点に一致した状態でインポートされます。
ポジショナのジオメトリ構造を確認します。
3Dワールド上のジオメトリをクリックすると、[コンポーネントグラフ]ウィンドウのフィーチャツリーが展開され、選択されたジオメトリが表示されます。
ジオメトリを分解したい場合は、フィーチャツリーを右クリックし、[エクスプロード]を選択する方法と[ジオメトリ]-[ツール]-[スプリット]を選択する方法があります。
今回は、分解する必要がないため、そのままにします。
フィーチャツリーのcompact_positioner_tilt_1を選択します。
3Dワールド上で緑色にハイライトされたジオメトリを右クリックします。
[抽出]-[抽出リンク]を選択します。
[コンポーネントグラフ]ウィンドウを確認すると、[Link_1]という名前のリンクが作成されていることがわかります。
フィーチャツリーを展開すると、先ほど選択したジオメトリが表示されます。
コンポーネントノードツリーのルートノードを選択します。
フィーチャツリーを確認すると、分解したジオメトリ以外の2つのジオメトリが残っています。
3Dワールド上で回転テーブルを選択します。
[抽出]-[抽出リンク]を選択します。
[コンポーネントグラフ]ウィンドウを確認すると、[Link_2]という名前のリンクが作成されていることがわかります。
コンポーネントノードツリーのルートノードを選択します。
フィーチャツリーを確認すると、分解したジオメトリ以外の1つのジオメトリが残っています。
分解後に残った空のジオメトリ保管用のデータが残っているため、削除します。
フィーチャツリーの任意の場所を選択します。
右クリックし、[空を削除]を選択します。
コンポーネントノードツリーの[Link_1]を選択します。
[リンクプロパティ]ウィンドウの[Name]で名前をLink_Tiltに変更します。
Link_Tiltが回転するように設定します。
Link_Tiltの原点を回転軸にするため、軸を円柱に移動します。
[マニピュレーション]-[移動]を選択します。
Z軸の矢印を+Z軸方向に移動すると、Link_Tiltのジオメトリも移動します。
原点のみを移動させたいため、位置を元に戻します。
[リンクプロパティ]ウィンドウのZのアイコンをクリックし、リセットします。
[移動モード]の[選択済み]を選択します。
[選択済み]は、選択したオブジェクトのみを移動させることができます。
Z軸の矢印を+Z軸方向にドラッグすると、Link_Tiltの原点のみ移動します。
ドラッグする際、左クリックを押したままの状態でShiftキーを押します。
整列したいターゲットを選択するマークが表示されるため、円柱の中心に位置を合わせ、Shiftキーと左クリックを外します。
原点の位置が問題ないか確認します。
左下のLをクリックし、ビューを回転させます。
ツールバーの正投影表示をONにします。
レンダリングモードをワイヤーフレームにします。
原点が円柱の中心にあることがわかります。
レンダリングモードをシェード、正投影表示をOFFにし、ビューをフロントに戻します。
Link_Tiltに回転の動作を設定します。
[リンクプロパティ]ウィンドウの[JointType]は、[固定]、[回転]、[直進]、[回転フォロワー]、[直進フォロワー]、[カスタム]を選択できます。
今回は、Link_Tiltを回転させるため、[回転]を選択します。
軸は、X軸を中心として回転させるため、+Xを選択します。
Link_Tiltの動きを制御する設定を追加します。
ジョイントプロパティの[Name]で名前をE1に変更します。
[リンクプロパティ]ウィンドウの[Controller]を[新規サーボコントローラ]に設定します。
Controllerが「サーボコントローラ」になります。
[コンポーネントグラフ]ウィンドウを確認すると、[ビヘイビア]に「サーボコントローラ」が作成されていることがわかります。
再度Link_Tiltを選択します。
回転の可動域の最大値と最小値を設定します。
[最小リミット]と[最大リミット]はデフォルトのままにします。
[最大速度]は360にし、最大で1秒間に360°回転できるようにします。
[最大加速]、[最大減速]は、360°の4倍になるため、360×4を入力すると、1440になります。
つまり、0.25秒で最大速度360°に達します。
[コンポーネントグラフ]ウィンドウの「Link_2」を選択します。
[リンクプロパティ]ウィンドウの[Name]で名前をLink_Rotaryにします。
[マニピュレーション]-[インタラクティブ]を選択し、Link_Tiltを動かすと、X軸に沿って回転しますが、Link_Rotaryは動きません。
シミュレーションをリセットします。
Link_RotaryがLink_Tiltに合わせて動くようにするには、Link_Tiltの子ノードにする必要があります。
[マニピュレーション]-[移動]を選択します。
[構造]-[表示]のチェックボックスを選択し、リンクの構造を3Dワールド上で表示します。
Link_Rotaryの原点は、底面にありますが、Link_Tiltの原点は床よりも高い位置にあります。
コンポーネントノードツリーのLink_RotaryをLink_Tiltにドラッグ＆ドロップします。
回転テーブルがLink_Tiltの原点の位置を継承し、+Z軸方向に移動していることがわかります。
回転テーブルの位置が移動しないよう修正します。
Link_Rotaryをルートノードにドラッグ&ドロップし、Link_Tiltとの親子関係を一旦解除します。
Shiftキーを押しながら、Link_RotaryをLink_Tiltにドラッグ＆ドロップすると、位置を保持したまま、親子関係にすることができます。
リンクの構造を確認します。
コンポーネントノードツリーのルートノードを選択し、3Dワールドのリンクを確認すると、運動の主軸は底面にあることがわかります。
Link_Tiltを選択し、3Dワールドのリンクを確認すると、運動の主軸は床より上にあることがわかります。
Link_Rotaryを選択し、3Dワールドのリンクを確認すると、運動の主軸は底面にあることがわかります。
Link_Rotaryは回転ロータリーの中心を軸として回転させるため、運動の主軸を修正します。
[移動モード]の[選択済み]が選択された状態で、3Dワールド上から原点を移動するか、[ツール]-[スナップ]で原点を移動します。
3Dワールド上で原点のピンクの丸を選択し、Shiftキーを押しながら、回転ロータリーの中心にドラッグ&ドロップします。
Link_Rotaryに回転の動作を設定します。
[リンクプロパティ]ウィンドウの[JointType]で[回転]を選択します。
軸は、Z軸を中心として回転させるため、+Zを選択します。
Link_Rotaryの動きを制御する設定を追加します。
ジョイントプロパティの[Name]で名前をE2に変更します。
[リンクプロパティ]ウィンドウの[Controller]は、Link_Tiltで作成した[サーボコントローラ]を使用します。
回転の可動域の最大値と最小値を設定します。
[最小リミット]は-360にします。
[最大リミット]は360にします。
[最大速度]は360にし、最大で1秒間に360°回転できるようにします。
[最大加速]、[最大減速]は、360°の4倍になるため、360×4を入力すると、1440°になります。
Link_TiltとLink_Rotaryの動作を確認します。
[マニピュレーション]-[インタラクティブ]を選択し、Link_Tiltを動かすと、Link_TiltとLink_RotaryがX軸に沿って回転します。
Link_Rotaryを動かすと、Link_RotaryがZ軸に沿って回転します。
シミュレーションをリセットします。
2軸回転ポジショナを作成する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

2軸回転ポジショナを作成し、ロボットと接続しよう(2/2)

オリジナルの2軸回転ポジショナを作る方法と、ロボットと接続する方法（ウィザードのポジショナ、ロボットのCompactPositionerAssembly設定）
https://youtu.be/hm2Vxspiwds
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_117_p2.zip

2軸回転ポジショナを作成し、ロボットと接続する方法を説明します。
パート1では、インポートしたモデルから、2軸回転ポジショナを作成しました。
パート2では、2軸回転ポジショナをロボットに接続し、ロボットのプログラムを使用して、動作を制御します。
パート1で作成した2軸回転ポジショナ、もしくは、[Modeling a Workpiece Positioner  - Part1_after.vcmx]をダウンロードし、開きます。
2軸回転ポジショナとロボットを接続するためのインターフェースを設定します。
[モデリング]タブを開きます。
2軸回転ポジショナを選択します。
通常、[動作設定]-[ビヘイビア]-[インターフェース]で、インターフェースの詳細を設定する必要があります。
ポジショナのような一般的な製品は、ウィザードを使用することで、詳細な設定をせずにインターフェースを設定できます。
[追加]-[ウィザード]-[ポジショナ]を選択します。
[ポジショナ]ウィンドウの[ポジショナータイプ]でWorkpiece PositionerやRobot Positionerを選択できます。
Workpiece Positionerは、ロボットとリモートで接続し、ジョイントの値をロボットにエクスポートするためのインターフェースです。
Robot Positionerは、ロボットと物理的に接続し、ジョイントの値をロボットにエクスポートするためのインターフェースです。
今回は、ロボットとリモートで接続するため、Workpiece Positionerを選択します。
[フランジの接合]は、ロボットまたはワークを取り付けるリンクを選択します。
リンクの構造の中で、最後のリンクを指定する必要があります。
[コンポーネントグラフ]ウィンドウのLink_Tiltを展開すると、Link_Rotaryが構造の最後のリンクになっていることがわかります。
[フランジの結合]を確認すると、デフォルトでLink_Rotaryが選択されています。
[適用する]ボタンをクリックします。
[コンポーネントグラフ]ウィンドウのビヘイビアを展開すると、「RobotInterface」が追加されていることがわかります。
[出力]ウィンドウを確認すると、ワークプレースポジショナのビヘイビアが作成され、ウィザード用のウィンドウを閉じて良いという内容のメッセージが表示されます。
[出力]ウィンドウを右クリックし、メッセージを削除します。
[ポジショナ]ウィンドウの閉じるボタンをクリックし、ウィンドウを閉じます。
2軸回転ポジショナの色を変更します。
[マニピュレーション]-[移動]を選択します。
[構造]-[表示]のチェックを外します。
[ジオメトリ]-[ツール]-[マテリアル]-[割り当て]を選択します。
[マテリアルを割り当て]ウィンドウの[ライブラリ]タブを開きます。
[aluminium]を選択し、全ての部品をクリックします。
マテリアルを誤って割り当てた場合は、[モード]の[消去]を選択し、マテリアルを消したい箇所をクリックします。
[マテリアルを割り当て]ウィンドウの閉じるボタンをクリックし、ウィンドウを閉じます。
ロボットを追加します。
[ホーム]タブを開きます。
eカタログの[製造者別モデル]-[MITSUBISHI]-[Robots]を展開します。
[RV-13FL]を追加します。
[接続]-[インターフェース]を選択します。
3Dワールドに2軸回転ポジショナとロボットのインターフェースが表示されます。
2軸回転ポジショナを選択します。
3Dワールドのインタフェースの表示を確認すると、2軸回転ポジショナの[RobotInterface]とロボットの[Connect Workpiece Positioner]が接続されたことがわかります。
[インターフェースに接続]ウィンドウの閉じるボタンをクリックし、ウィンドウを閉じます。
[プログラム]タブを開きます。
2軸回転ポジショナとロボットの動きをプログラムで制御します。
ロボットを選択します。
[コンポーネントプロパティ]ウィンドウの[ジョグ]タブを開きます。
[ジョグ]ウィンドウの[ジョイント]の項目で、ロボットを動かします。
J1のスライダーを左へ動かします。
[CompactPositionerAssembly]の項目で、2軸回転ポジショナを動かします。
E1とE2のスライダーを右へ動かします。
[RV-13FL]ウィンドウの[サブプログラム]-[Main]に[各軸補間ステートメント]を追加します。
[各軸補間ステートメント]は、ロボットの位置を記録し、軸に沿って順番に動かすことができます。
ロボットのフレームの緑の面を選択し、-Z軸方向に移動します。
2軸回転ポジショナの回転テーブルを回転し、Link_Tiltのコンポーネントを+Y軸方向に回転します。
[各軸補間ステートメント]を追加します。
シミュレーションをリセットします。
シミュレーションを実行します。
2軸回転ポジショナとロボットが、[サブプログラム]で設定した動作の通り、それぞれ動作していることがわかります。
2軸回転ポジショナを作成し、ロボットと接続する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

3DCADの機構情報を引き継いでみよう

3DCADファイルの機構情報を引き継いでインポートする方法
https://youtu.be/qcJOxSUj8qQ
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_110.zip

3DCADで設定した機構情報を引き継ぐ方法について説明します。
CADファイルをインポートする時、機構情報の引き継ぐ方法を定義できます。
ただし、可動部の動作範囲など、引き継ぐことができない情報もあります。
CADファイルをインポートします。
[ホーム]タブ、または[モデリング]タブをクリックします。
[インポート]グループの[ジオメトリ]をクリックすることで、CADファイルをインポートできます。
[Generic Articulated Robot.step]を選択し、[開く]をクリックします。
[モデルをインポート]ウィンドウでは、インポート時のプロパティを設定できます。
[構造]は、CADファイルを分割する方法を定義します。
[フィーチャ]は、分割せず、すべてのジオメトリを同じコンポーネントに格納します。
[ノード]は、[フィーチャ]と同様に、コンポーネントは1つですが、すべてのジオメトリを別のノードに分割します。
[フィーチャ]と[ノード]は、単一のモデルとしてCADファイルをインポートできます。
[コンポーネント]は、ジオメトリをすべて別のコンポーネントに分割します。
レイアウトとしてCADファイルをインポートできます。
分割せず、1つのコンポーネントとしてインポートするため、[フィーチャ]を選択します。
[フィーチャツリー]は、ジオメトリの階層構造を定義することで、3DCADで設定した機構情報を、引き継ぐことができます。
[完全]は、トランスフォームフィーチャを使用し、3DCADと階層構造を完全に一致させます。
[最適化]は、すべてのジオメトリを同じ階層に設定できます。
[最小化]は、すべてのジオメトリを1つにまとめることができます。
3DCADで設定した機構情報を引き継ぐため、[完全]を選択します。
[上軸]で、ジオメトリの上面と底面を整列させる軸を定義します。
[+Z]を選択します。
[インポート]をクリックします。
ロボットのCADファイルをインポートできます。
ロボットの内部情報を確認するため、[モデリング]タブをクリックします。
ロボットを選択し、[コンポーネントグラフ]ウィンドウの下段を表示します。
Root[Generic Articulated Robot]の、左側にあるプラスアイコンをクリックします。
トランスフォームフィーチャが表示されます。
トランスフォームフィーチャは、数式を入力することで、子階層のフィーチャを変形、および移動させることができます。
トランスフォームフィーチャで使用できる数式は、ヘルプファイルで確認できます。
[ヘルプ]タブを開き、[ヘルプ]をクリックします。
[目次]で[数式]を展開し、[関数]をクリックします。
[ベクトル及び行列構築関数]を使用することで、フィーチャを変形、および移動させることができます。
[モデリング]タブを開きます。
トランスフォームフィーチャの、左側にあるプラスアイコンをクリックしていくと、階層構造になっていることが確認できます。
[Axis]が機構情報を持ち、[GeoContainer]がジオメトリを格納しているトランスフォームフィーチャです。
モデルに可動部を設定する時、引き継いだ機構情報を利用する場合があります。
その場合、インポート時に異なるプロパティを選択します。
CADファイルをインポートします。
[インポート]グループの[ジオメトリ]をクリックします。
[Generic Articulated Robot.step]を選択し、[開く]をクリックします。
[モデルをインポート]ウィンドウの[構造]は、3DCADで設定した機構情報に基づき、CADファイルを分割できます。
先程は、[フィーチャ]を選択しましたが、今回は、[ノード]を選択します。
[インポート]をクリックします。
ロボットを選択し、[コンポーネントグラフ]ウィンドウの上段を表示します。
[Generic Articulated Robot#2]の、左側にあるプラスアイコンをクリックします。
ノードが表示されます。
ノードの左側にあるプラスアイコンをクリックしていくと、階層構造になっていることが確認できます。
[GeoContainer]という名前のノードには、ジオメトリが1つ格納されています。
[Axis]という名前のノードは、[リンクプロパティ]ウィンドウの[Offset]で軸の位置を定義しています。
3DCADで設定した機構情報を引き継ぐ方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

3DCADモデルを簡素化しよう

インポートした3DCADを簡素化し、システムの負荷を減らす方法（関連動画：シミュレーション性能を最適化しよう）
https://youtu.be/DMlfRmg29Z4
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_165.zip

インポートした 3DCADモデルを簡素化する方法を説明します。
GeminiでサポートしているCADファイルを確認します。
[ヘルプ]タブを開きます。
[ヘルプと参照]-[ヘルプ]を選択します。
[サポートされているCADファイル]をクリックします。
Geminilは、3Dモデル、図面など様々なCADファイルのインポートとエクスポートに対応しています。
3Dモデルは三角形のメッシュが多いほど、コンポーネントの品質が高くなります。
CADモデルをインポートする場合、モデルにはシミュレーションでは必要ない詳細が多く含まれている可能性があります。
CADファイル内のジオメトリを簡素化すると、システムの処理能力が大幅に向上します。
3DCADモデルをインポートして、簡素化する手順を説明します。
ロボットのCADファイルをインポートします。
Robot Sample.stp]をダウンロードします。
[ホーム]タブを開きます。
[インポート]-[ジオメトリ]を選択します。
[Robot Sample.stp]を選択し、開きます。
[モデルをインポート]ウィンドウの[テッセレーションの品質]を左にスライドし、超低品質にします。
[分析]を選択します。
約270189個の三角形があることがわかります。
もし、3Dワールドにこのロボットを4体インポートすると約100万個の三角形があるため、三角形の数が多くなり、処理能力が低下します。
[インポート]をクリックします。
コンポーネントを簡素化する手順を説明します。
[モデリング]タブを開きます。
[ジオメトリ]-[ツール]を選択すると、簡素化するためのツールが表示されます。
[マニピュレーション]-[移動]が選択された状態で、ロボットの台座を選択します。
[ジオメトリ]-[ツール]-[平易化]-[簡略化]を選択します。
簡略化は、設定された範囲内で、近くにある線や点をまとめることで、細かい部分を統合し、ジオメトリをシンプルにします。
[簡略化]ウィンドウの[最大のエラー]を1mm、[クオリティ]を40にします。
最大のエラーは、マージする際に元の形状から何mmまでずれてよいかを設定します。
マージとは複数のデータやファイルを統合して一つのデータやファイルにすることです。
クオリティは、選択したフィーチャに必要なデータ数を指定します。
簡略化をクリックします。
[出力]ウィンドウを確認すると、総三角形数が6342から4769へ変更されたことが表示されます。
簡略化ツールを使用すると、コンポーネントを簡素化できたことがわかります。
ロボットの底面に視点を移動します。
ロボットの内部に複数のパーツが表示されていることがわかります。
3Dワールド上には表示されないフィーチャは、不要なため削除します。
ネジを削除してコンポーネントを簡素化する手順を説明します。
[AutoMaterialize_2.0]をダウンロードします。
[AutoMaterialize_2.0]には、Pythonスクリプトで記述されたアドオンが格納されています。
[ドキュメント]-[MITSUBISHI]-[Gemini]-[1.48]-[My Commands]を開きます。
[My Commands]に[AutoMaterialize_2.0]をドラック＆ドロップします。
My Commandsに追加されたデータは、Geminiを再起動しないと反映されないため、一旦保存し、再起動します。
ロボットを選択します。
[モデリング]タブを開きます。
[追加]-[ウィザード]-[My add-On]-[Auto Matelialize]を選択します。
Auto Matelializeは、複数のフィーチャのマテリアルを一括で変更できます。
また、複数のフィーチャを一括で削除できます。
マテリアルやフィーチャは、フィーチャのサイズ制限毎に、5段階設定できます。
[Auto Matelialize]ウィンドウのSize Limit1を30にし、直径30mm未満のジオメトリを指定します。
Applyをクリックします。
直径が30mm未満のすべてのフィーチャが赤で表示されています。
3Dワールド内を確認すると、数多くのネジがあることがわかります。
シミュレーションでは不要なため削除します。
[Auto Matelialize]ウィンドウの[Delite leverl 1]をクリックし、全てのネジを削除します。
[Auto Matelialize]ウィンドウの[Reset Materials]をクリックし、ロボットのマテリアルをリセットします。
三角形を数えて、どれぐらい簡素化できたかを確認します。
[ジオメトリ]-[ツール]-[平易化]-[三角形を数える]を選択します。
[三角形を数える]ウィンドウの[レイアウト]を選択すると、3Dワールド上にはロボットしかないため、ロボットの数を数えることができます。
[出力]ウィンドウを確認すると、総三角形数が38434と表示されています。
ネジを削除するとコンポーネントを簡素化出来たことがわかります。
ロボットのパーツを選択します。
[3Dワールドツールバー]の[レンダリング]-[ワイヤーフレーム]を選択すると、数多くの三角形が表示されています。
[ジオメトリ]-[ツール]-[平易化]にある様々な機能を使用して、三角形の数を減らします。
凸包を使用して、三角形の数を減らします。
[3Dワールドツールバー]の[レンダリング]-[マテリアルシェード]を選択します。
[ジオメトリ]-[ツール]-[平易化]-[凸包]を選択します。
凸包は、選択したフィーチャの各頂点を包む最小の多角形にします。
[出力]ウィンドウを確認すると、ジオメトリフィーチャを凸包に変換したことが表示されます。
形状が簡素化されましたが、見た目は元の形状から大幅に変更されていません。
ブロック化を使用して、三角形の数を減らします。
ロボットのパーツを選択します。
[ジオメトリ]-[ツール]-[平易化]-[ブロック化]を選択します。
ブロック化は、フィーチャを単純なブロック形状に変換します。
[ブロック]ウィンドウの[設定]-[オリジナルを表示]にチェックを入れると、元のフィーチャが表示されます。
元のフィーチャから見た目が大きく変わらないことが確認できたため、[設定]-[オリジナルを表示]のチェックを外します。
[適用]をクリックします
側面のパーツも三角形が多く表示されていたため、ブロック化します。
ロボットのパーツを選択します。
[ジオメトリ]-[ツール]-[平易化]-[ブロック化]を選択します。
[ブロック化]ウィンドウの適用をクリックします。
円柱化を使用して、三角形の数を減らします。
ファンを選択します。
[ジオメトリ]-[ツール]-[平易化]-[円柱化]を選択します。
円柱化は、フィーチャを単純な円柱形状に変換します。
[円柱化]ウィンドウの適用をクリックします。
ブロック化や円柱化は、物によっては、形状が比較的変わりやすいため、複雑なパーツには凸包を使用することをおすすめします。
ロボットのパーツを選択します。
[ジオメトリ]-[ツール]-[平易化]-[凸包]を選択します。
形状が簡素化されましたが、見た目は元の形状から大幅に変更されていません。
三角形を数えて、どれぐらい簡素化できたかを確認します。
[ジオメトリ]-[ツール]-[平易化]-[三角形を数える]を選択します。
[三角形を数える]ウィンドウの[レイアウト]を選択します。
[出力]ウィンドウを確認すると、総三角形数が33929個と表示されています。
三角形は約270189個から33929個に減ったため、簡素化されたことがわかります。
インポートした 3DCADモデルを簡素化する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

AGVを作ってみよう（1/12）

オリジナルのAGVを作成して、基本の設定をする方法
https://youtu.be/RryrgWSkbI8
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_003_p1.zip

シミュレーション再生中に移動するAGVの作成方法を説明します。
AGVは無人搬送車とも呼ばれます。
設定は[モデリング]タブが必要になるため、MELSOFT Gemini Professionalを使用します。
eカタログで、移動ロボットやAGVを表示したい場合、[製造者別モデル]を展開し[Mobile Industrial Robots]をクリックします。
移動ロボットまたはAGVの、テンプレートとして使用できます。
今回は、ここに表示されているコンポーネントを作成する方法を説明します。
AGVの定義とPythonスクリプトを使用し、コンポーネントをAGVにする方法を説明します。
3Dワールドに、コンポーネントが1つもないことを確認し、[モデリング]タブに移動します。
新しいコンポーネントを作成し、[ジオメトリ]-[フィーチャ]から[ボックス]を作成します。
コンポーネントプロパティに移動し、[モデリング]タブの[コンポーネント]グループにある[新規]をクリックして新規コンポーネントを作成し、コンポーネントの名前を「Mobile Robot」に変更します。
バックアップのためにコンポーネントの変更を保存するため、[コンポーネント]-[保存]をクリックし、[コンポーネントを保存]ウィンドウで、[保存]ボタンをクリックすると、保存することができます。
次にコンポーネントにAGVの定義を設定します。
[動作設定]-[ビヘイビア]-[ビークル]をクリックし、AGVの動作設定を追加します。
[プロパティ]では、ビークルの詳細設定に[名前]しかないことがわかります。
AGVを定義するためには.NETまたはPythonAPIのいずれかを、使用する必要があります。
今回は、[Python API]を使用するため、[ビヘイビア]のメニューに戻り、[パイソンスクリプト]を追加します。
このスクリプトでは、OnRunを使用し、AGVを定義します。
最初に、スクリプトを追加したコンポーネントの、変数が必要なため、comp=getComponentと記述します。
次に、コンポーネントの変数を使用しAGVの動作を定義するため、vehicle=comp.getBehaviourと記述します。
()内にビークルのデフォルト名であるvehicleと記述します。
print vehicleと記述することで、vehicleの情報を表示することができます。
ウィンドウ左上にあるコンパイルをクリックしPythonスクリプトをコンパイルします。
シミュレーションを再生し、リセットし、出力ウィンドウを確認すると、ビークルは、VC SIMビークルの一種であることが分かります。
ビークルの詳細については、[ヘルプ]タブを参照します。
[ヘルプ]タブをクリックし、[パイソンAPI]をクリックし、リファレンスガイドを開きます。
リファレンスガイドで、VC SIM ビークルに関する内容を確認してください。
pythonでAGVを定義し、動作させるための方法を確認することができます。
定義の中では、AGVの加速、減速、最高速度などを定義することができます。
AGVを定義する前に、clearMoveというメソッドを、呼び出す必要があります。
clearMoveは、AGVの移動経路からすべてのポイントを削除することで、AGVを完全に停止させ、最初からやり直すことができます。
スクリプトに、vehicle.clearMove()と記述し、次に、AGVの加速度を定義します。
vehicle.Acceleration=300.0と記述します。単位はミリ毎秒です。
そして、減速についても同様に記述します。
vehicle.Deceleration=300.0
AGVの最高速度は、800の値を使用します。
設定した値がどういった役割か、ヘルプで確認します。
APIリファレンスに戻り、vcSimVehicleの先頭に移動します。
この図を見ると、AGVが動作するとき、加速し、最高速度に到達します。
そこから、AGVは減速し、停止または曲がり、次のポイントに進み、その後、終了位置に到達すると停止します。
パイソンスクリプトに戻り、パイソンスクリプトをコンパイルし、シミュレーションを再生すると、AGVに対して移動先を指定していないため、動作しません。
AGVを動作させたい場合は、移動先を指定する必要があります。
シミュレーションをリセットし、スクリプトに、import vcVectorと記述すると、新しいベクトルを作成することができます。
point=vcVector.newと記述し、AGVの移動先を指定します。
()内はX、Y、Zの順に値を記述していくため、Xは2000、YとZは0と記述します。
次に、この移動先をAGVに割り当てる必要があります。
vehicle.addControlPoint(point)と記述を追加します。
このメソッドを使用すると、AGVに移動先を追加できるため、引数はベクトルである必要があります。
パイソンスクリプトをコンパイルします。
動作を確認します。
AGVの動作はX軸に沿って移動し、そのポイントで停止する動作になっています。
シミュレーションを再生します。
X軸方向に移動し、停止しました。
シミュレーションをリセットすると、AGVは最初の位置に戻り、最後の位置には留まりません。
AGVの作成方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

AGVを作ってみよう（2/12）

オリジナルのAGVの経路を可視化する方法
https://youtu.be/-izO0_q77EM
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_003_p2.zip

AGVの移動経路を可視化する方法を説明します。
シミュレーション再生中にAGVの移動経路を確認することが難しいため、ロボットの掃引ボリューム機能を使用しAGVの移動経路を可視化する方法を説明します。
[ホーム]タブをクリックし、eカタログの[タイプ別モデル]に移動します。
[Robots]を展開し、[Visual Components]をクリックし、[Generic Articulated Robot]を3Dワールドに追加します。
3Dワールドでロボットを選択し、コンポーネントプロパティを表示します。
アクション設定を展開します。
[出力]を81に設定すると、[出力]81がTrueの場合、掃引ボリュームオンを実行し、Falseの場合、掃引ボリュームオフを実行します。
[掃引したジオメトリ]を展開します。
リストからロボットを削除後、掃引したジオメトリを使用し、AGVを選択します。
掃引ボリュームオンを実行するとき、移動経路をどのように表示するかを設定するために、[掃引の方法]を[Lofting]に変更します。
掃引したジオメトリを実行するために、透明なマテリアルを使用します。
[マテリアル]でtransp_orangeを選択します。
後で確認できるように、ジオメトリを保存するオプションもありますが、この動画では行いません。
機能を確認するために、ロボットに掃引ボリュームオンを実行するための指示をする必要があります。
[プログラム]タブに移動し、[プログラムエディタ]で、セットバイナリ出力ステートメントを追加します。
ステートメントプロパティのバイナリ出力ステートメントを81に変更し、出力値をTrue の値にします。
シミュレーションを再生すると、AGVのジオメトリが掃引されるためAGVの移動経路を確認することができます。
シミュレーションをリセットすると、掃引ボリュームは保存されないため、軌跡が消えます。
シミュレーション再生中はAGVの移動経路を表示することができます。
AGVの移動経路を可視化する方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

AGVを作ってみよう（3/12）

オリジナルのAGVを動かす方法
https://youtu.be/htlTQ_Tf3O8
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_003_p3.zip

AGVを複数の座標位置やその他のコンポーネントの座標まで移動させる方法を説明します。
AGVのパスに複数の座標位置を追加する方法を説明します。
AGVのPythonスクリプトを開き、変数名をpointからpoint1に変更し、変数名がpoint2の、新しいベクトルを作成します。
X、Yを2000に、Zを0にします。
AGVのパスに、複数の位置座標を追加する場合、for文を記述する方法があります。
for p in [point1, point2]:と記述し、改行します。
vehicle.addControlPoint(p)と記述することで、point1に移動後、point2に移動し、停止します。
Pythonスクリプトをコンパイルし、シミュレーションを再生します。
先ほどの設定通りに動作します。
AGVを他のコンポーネントの位置に移動させる方法を説明します。
ロボットの位置に、移動する指示を出します。
シミュレーションをリセットし、[ホーム]タブに戻ります。
ロボットを選択し、移動します。
AGVのPythonスクリプトを開き、point1と、point2と、for文をコメントアウトします。
app=getApplication()と記述します。
ロボットのコンポーネントを指定するため、robot=app.findComponent()と記述し、カッコ内に、コンポーネント名を記述することで、ロボットを指定することができます。
ロボットのコンポーネントプロパティに、表示されているロボットの名前を記述します。
3Dワールドでの、ロボットのワールド位置座標を取得するため、wpm = robot.WorldPositionMatrixと記述します。
vcMatrixオブジェクトの位置ベクトルは、P属性を取得することで、アクセスすることができます。
新しい変数robot_pointを作成し、wpm.Pと記述することで、ロボットのワールド位置座標のP属性を、取得することができます。
AGVをロボットの位置まで移動させます。
vehicle.addControlPoint(robot_point)と記述します。
Pythonスクリプトをコンパイルし、動作を確認します。
シミュレーションを再生します。
AGVは、ロボットの位置に移動します。
ロボットの位置座標を、取得する以外の方法を説明します。
ロボットの位置座標を、取得する記述をコメントアウトし、新しい変数p1を作成し、AGVの現在位置を取得します。
comp.PositionMatrix.Pと記述することで、AGVの位置ベクトルを、操作することができます。
次変数p2を作成し、robot.PostionMatrix.Pと記述します。
ロボットの位置を、AGVに割り当てます。
p1からp2に移動させるため、p2-p1と記述します。
AGVからロボットへの、ベクトルを取得することができます。
Pythonスクリプトをコンパイルし、シミュレーションを再生します。
AGVは、ロボットの位置に移動します。
座標の位置ベクトルの参照について説明します。
シミュレーションをリセットし、ロボットにフレームを作成し、AGVが移動する位置を指定します。
コンポーネントの原点を使用していますが、フレームを使用することもできます。
ロボットを選択し、[モデリング]タブに移動します。
コンポーネントグラフのルートノードを選択し、[ジオメトリ]-[フィーチャ]-[フレーム]を追加します。
フレームをX軸方向に移動し、ロボットから遠ざけます。
次に、フレームの名前を[フィーチャプロパティ]ウィンドウ-[名前]で、「PickUpLocation」に変更します。
AGVのPythonスクリプトに戻り、AGVとロボットのベクトルを使用します。
ロボットに追加したフレームを取得するため、変数frameを作成します。
robot.getFeatureと記述することで、ロボットコンポーネント内のフィーチャを取得することができます。
カッコ内に、PickUpLocationと記述します。
npm=frame.NodePositionMatrixと記述し、ノードに対するフレームの相対的な位置を取得しています。
座標の位置ベクトルを取得することもできます。
frame_point=npm.Pと記述します。
AGVが移動する指示を出します。
P1、P2を削除します。
AGVがフレームの位置に移動するため、frame_pointと記述します。
Pythonスクリプトをコンパイルし動作を確認します。
シミュレーションを再生します。
AGVは、ロボットの位置座標を取得しているため動作しません。
想定ではベクトルを割り当てるとき、AGVは、ロボットの現在位置ではなく、相対的な位置を参照する想定でした。
修正する方法を説明します。
ロボットのワールド位置座標を使用し、フレームのワールド位置座標を取得します。
フレームとロボットコンポーネントがあります。
wpm=robot.WorldPositionMatrixと記述し、ロボットのワールド位置座標を取得します。
変数npmは、フレームのノード位置座標を取得しているので、frame_point=(wpm*npm).Pと記述します。
フレームのノード位置座標に、ロボットのワールド位置座標をかけることで、フレームのワールド位置座標を取得しています。
コードをコンパイルし、シミュレーションを実行します。
AGVはフレームの位置に移動します。
AGVを複数の座標位置やその他のコンポーネントの座標まで移動させる方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

AGVを作ってみよう（4/12）

オリジナルのAGVの走行経路を補間する方法
https://youtu.be/xoKAAvcQ8KU
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_003_p4.zip

AGVの移動経路を補間する方法を説明します。
Pythonスクリプトにある、ロボットとフレームの位置座標を取得する記述を削除します。
コメントアウトしていた、point1とpoint2とfor文を、元に戻します。
Pythonスクリプトをコンパイルします。
シミュレーションを再生し、AGVが直進することを確認します。
デフォルトでは、AGVの経路の補間は0であるため、原点からpoint1、pont1からpoint2まで直進します。
補間値を変更し値による変化を確認するため、シミュレーションをリセットします。
スクリプトで、AGVの速度を定義した後、AGVの補間値を0.35に設定します。（vehicle.Interpolation = 0.35）
0.35に変更することで、AGVのパスをカーブさせることができます。
Pythonスクリプトをコンパイルし、シミュレーションを再生します。
AGVはカーブを描きながらpoint1を通過後、再度カーブを描きながらpoint2まで走行し停止します。
シミュレーションをリセットし、補間値を0.8に変更します。
Pythonスクリプトをコンパイルし、シミュレーションを再生します。
補間値が0.35のときより、大きなカーブを描き、AGVは減速と加速を繰り返し、point1を通過後、point2で停止します。
シミュレーションをリセットします。
補間値を1.5に変更し、Pythonスクリプトをコンパイルします。
シミュレーションを再生します。
AGVは、円を描き走行します。
補間値は0.25、または0.2から0.4に設定することで、適切なカーブを描きます。
補間値を0に戻し、Pythonスクリプトをコンパイルします。
シミュレーションを実行します。
AGVのパスは直線に戻りました。
AGVの移動経路を補間する方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

AGVを作ってみよう（5/12）

オリジナルのAGVの情報を読取って動作を制御する方法
https://youtu.be/rYt_yawkwns
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_003_p5.zip

AGVのパスを使用し、合計時間または移動時間を確認することができます。
AGVがパスの開始位置から終了位置まで移動する必要があります。
パスの距離を取得することができるためPythonスクリプトで設定します。
シミュレーションをリセットしAGVのパスを定義した後、合計時間を取得します。
「print vehicle.TotalTime」と記述します。
パスの距離を取得するため「print vehicle.PathLength」と記述します。
合計時間と距離はAGVのパスを定義した後取得することができます。
AGVの現在の値を参照するためです。
Pythonスクリプトをコンパイルし、シミュレーションを再生します。
[出力]ウィンドウを確認します。
AGVが移動するためにかかる時間は、約7.6秒です。
AGVのパスの距離は4000です。
補間値が0より大きい場合AGVの合計時間とパスの距離の変化を確認します。
シミュレーションをリセットし補間値を0.6に設定します。
Pythonスクリプトをコンパイルしシミュレーションを再生します。
[出力]ウィンドウを確認します。
合計時間が8.1秒になり距離は約4400に増加しました。
シミュレーションをリセットします。
補間値を0に戻します。
AGVにパスの終了位置ではない位置で停止する指示を出すことができます。
コンパイルを押さなくてもリセットするとコンパイルされます。
シミュレーションをリセットします。
print文をコメントアウトまたは削除します。
AGVのパスの距離を取得します。
「d = vehicle.pathLength」と記述します。
AGVを停止するため「vehicle.resetStopAtDistance」と記述します。
停止するAGVのパス上での距離を変更することができます。
パスの終了位置ではなく途中で停止するためカッコ内は距離を2で割った値です。
Pythonスクリプトをコンパイルしシミュレーションを再生します。
AGVはpoint1に到達しパス全体の約半分の位置で停止しました。
時間を取得し停止させることもできます。
シミュレーションをリセットします。
距離を取得し停止する行を、コメントアウトまたは削除します。
時間を取得するため「t = vehicle.TotalTime」と記述します。
AGVの移動時間を取得しました。
遅延を作成する必要があります。
AGVに停止する指示を出す前に、移動時間の半分の時間遅延させます。
AGVに完全に停止する指示を出します。
「vehicle.clearMove()」と記述します。
Pythonスクリプトをコンパイルし、シミュレーションを再生します。
AGVは停止しました。
途中でAGVの移動経路を変更します。
衝突の可能性を検出する移動ロボットがある場合、衝突を回避するためロボットを別の位置に移動させる必要があります。
Pythonスクリプトの記述を変更します。
シミュレーションをリセットし「clearMove」の行をコメントアウトします。
「vehicle.rePlan」と記述します。
AGVにポイントを追加しpoint1とpoint2へ移動する経路を変更します。
for文をコメントアウトします。
AGVにpoint1への移動指示を出すため、「vehicle.addControlPoint(point1)」と記述します。
AGVがpoint1に移動するまでにかかる時間を取得します。
AGVにpoint1に移動する指示を出しているため、合計時間はpoint1までのパスを参照していますが、point1からpoint2までのパスは参照していません。
point1の途中で停止しpoint2に移動する指示を出すため、「vehicle.addControlPoint(point2)」と記述します。
Pythonスクリプトをコンパイルし、シミュレーションを再生します。
AGVはpoint1までの約半分の位置に移動後、移動経路を変更しpoint2に直行しました。
AGVの情報を読み取って動作を設定する方法の説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

AGVを作ってみよう（6/12）

オリジナルのAGVを回転させる方法
https://youtu.be/qK-dP_iWrwA
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_003_p6.zip

シミュレーションをリセットします。
合計時間と距離の使用方法については別の動画で説明しました。
位置を変えずAGVを回転させる方法を説明します。
「addControlPoint」から下の記述をコメントアウトまたは削除します。
point1に移動します。
「vehicle.addControlPoint(point1)」と記述します。
AGVの合計時間分遅延させます。
「t = vehicle.TotalTime」と「delay(t)」と記述します。
AGVがpoint1で停止した後、所定の位置で回転させます。
「vehicle.rotateInPlace()」と記述します。
「rotateInPlace」は4つの引数を取得します。
1つ目の引数は回転角度です。
vehicleはコンポーネント内のZ軸を中心に回転します。
180度回転する設定をします。
2つ目の引数は回転の速度です。
50に設定します。
最後の2つの引数は回転の加速と減速です。
両方50に設定します。
Pythonスクリプトをコンパイルしシミュレーションを再生します。
AGVはpoint1で停止し所定の位置で回転しています。
AGVが回転中に90度の時点で停止させます。
シミュレーションをリセットします。
AGVを回転させているため、AGVの合計時間はpoint1に移動したときと異なるため、新しい遅延を使用します。
AGVが180度回転するためにかかる時間を取得するため「t = vehicle.TotalTime」と記述します。
新しい遅延を作成し合計時間の半分の時間を設定します。
180度回転するための時間の半分です。
AGVが完全に停止するため「vehicle.clearMove()」と記述します。
Pythonスクリプトをコンパイルし、シミュレーションを再生します。
AGVは停止し90度回転しました。
次にpoint1で回転し停止するのではなく、移動する設定にします。
Pythonスクリプトに戻り「clearMove」を削除し「rePlan」と記述します。
point2に移動するため「vehicle.addControlPoint(point2)」と記述します。
Pythonスクリプトをコンパイルし、シミュレーションを再生します。
AGVはpoint1に移動し90度回転した後、point2に移動しました。
以上でAGVを回転させる方法の説明を終わります。
ご視聴いただきありがとうございました。

=================================================================================

B接点センサーを作ろう

B接点センサーを作成する方法（レイキャストセンサー、PythonScriptでセンサーシグナルの値の反転）
（関連動画：レイキャストセンサーを使ってみよう、ボリュームセンサーを使ってみよう、センサーを作ってみよう）
https://youtu.be/zoYSSmAxFUw
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_172.zip

B接点センサーを作成する方法について説明します。
センサーがワークを検出していない時、シグナルがOFFになり、検出した時、シグナルがONになるセンサーをＡ接点センサーと言います。
B接点センサーとは、センサーがワークを検出していない時、シグナルがONになり、検出した時、シグナルがOFFになるセンサーです。
Geminiの[モデリング]タブ-[動作設定]グループ-[ビヘイビア]で設定可能なセンサー機能は、A接点センサーです。
A接点センサーについては、動画「レイキャストセンサーを使ってみよう」、「ボリュームセンサーを使ってみよう」、および「センサーを作ってみよう」を参照してください。
A接点センサーのシグナルをPythonScriptにより反転させることで、B接点センサーを作成します。
事前ファイル「Bsensor_before.vcmx」を開きます。
センサーのCADファイルをインポートします。
[ホーム]タブ、または[モデリング]タブを開きます。
[インポート]グループの[ジオメトリ]を選択することで、CADファイルをインポートできます。
[Sensor.3ds]を選択し、[開く]をクリックします。
[モデルをインポート]ウィンドウでは、インポート時の詳細を設定できます。
ジオメトリの階層構造をシンプルな状態にするため、[フィーチャツリー]で[最適化]を選択します。
ジオメトリの上面と底面を整列させる軸を設定するため、[上軸]で[-X]を選択します。
[インポート]をクリックします。
センサーのCADファイルをインポートできたことがわかります。
A接点センサーを作成します。
[モデリング]タブを開きます。
センサーが検出する位置を設定するため、フレームを追加します。
フレームとは、3Dワールド上で、位置と方向を定義する基準点です。
[ジオメトリ]グループの[フィーチャ]を展開し、[その他]から[フレーム]を選択します。
3Dワールドに、フレームが表示されない場合、3Dワールドツールバーの[フレームタイプ]を展開し、フレームにチェックを付けます。
[フレームタイプ]アイコンが透明な場合、機能は無効となっているため、アイコンを選択し、有効にする必要があります。
3Dワールドに、フレームを表示できます。
フレームを移動させます。
フレームを選択した状態で、[ツール]グループの[スナップ]を選択します。
[スナップ]は、選択しているものを、3Dワールドの選択した位置に移動できる機能です。
選択しているものの、原点を基準に移動できます。
センサーモデルの中心を選択します。
ワークを検出するため、センサーを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[センサー]から[レイキャスト]を選択します。
レイキャストセンサーは、定義したフレームの位置から光線を照射し、光線と交差したコンポーネントを検出できます。
センサーの位置を、フレームを選択して、定義します。
[プロパティ]ウィンドウの[フレーム]で、フレームを選択します。
選択したフレームの+Z軸方向に光線は照射されます。
表示する光線の長さと、ワークを検出する範囲を設定します。
[最大範囲]は、センサーと、検出したコンポーネントとの距離を測定できる範囲です。
[シグナル範囲]で、実数型シグナルを定義することで、距離を出力できます。
今回、距離は測定しませんが、3Dワールドに表示される光線の長さを変更するため、[最大範囲]を900に変更します。
[検出しきい値]は、コンポーネントを検出できる範囲です。
[検出しきい値]を900に変更します。
3Dワールド上の光線の表示/非表示は、[光線表示]で変更可能です。
ワークの検出を通知する場合、[ブールシグナル]を設定します。
ブールシグナルとは、ON/OFFの値を送受信できるシグナルです。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[ブール型]を選択します。
[プロパティ]ウィンドウの[名前]をASignalに変更します。
[コンポーネントグラフ]ウィンドウの[RaycastSensor]を選択します。
[ブールシグナル]で、ASignalを選択します。
B接点センサー用のシグナルを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[ブール型]を選択します。
[プロパティ]ウィンドウの[名前]をBSignalに変更します。
ASignalを利用し、BSignalの値を変更します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
Pythonスクリプトエディタが自動的に開きます。
センサーのシグナルを、グローバル変数として定義します。
パイソンスクリプトを含むコンポーネントの情報を取得するため、comp = getComponent()と記述します。
asig = comp.findBehaviourと記述することで、コンポーネントのビヘイビアを参照できます。
カッコ内にASignalと記述し、名前が一致するビヘイビアを参照します。
同様に、BSignalを参照します。
変数名は、bsigです。
ASignalがONの時、BSignalはOFF、ASignalがOFFの時、BSignalはONにします。
ASignalの値が変化した時、実行するため、関数OnSignalに処理を記述します。
関数OnSignalは、PythonScriptに接続されたシグナルの値が変化した時、処理を実行できます。
引数signalには、PythonScriptと接続されたシグナルが代入されます。
引数がASignalである場合、処理を実行するため、「if signal == asig:」と記述します。
ASignalがONである条件を追加するため、if signal.Value == True:と記述します。
BSignalをOFFにするため、bsig.signal(False)と記述します。
else:と記述することで、ASignalがONでない場合、処理を実行できます。
BSignalをONにするため、bsig.signal(True)と記述します。
シミュレーション開始時、ワークはセンサーと離れているため、センサーはワークを検出しません。
ASignalはOFFですが、シミュレーション開始後に値が変化していないため、関数OnSignalの処理を実行できず、BSignalはONになりません。
BSignalをONにするため、シミュレーション開始時に処理を実行する関数OnRunに、bsig.signal(True)と記述します。
PythonScriptをコンパイルします。
PythonScriptにシグナルの値を通知するため、接続します。
ASignalを選択します。
[プロパティ]ウィンドウの[接続]、[+]アイコンを選択します。
[Add Connections items]ウィンドウで、PythonScriptを選択することで、接続できます。
シグナルの値の変化を確認するため、シミュレーションを実行します。
センサーを選択します。
[接続]グループの[シグナル]を選択することで、3Dワールドと、画面右側にシグナルが表示されます。
BSignalを確認します。
ワークを検出していない時、ON、検出した時、OFFに変化したことがわかります。
シミュレーションをリセットします。
B接点センサーを作成する方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

CSVファイルを読み書きしよう(1/2)

パイソンスクリプト（Python）のスニペットを使用して、CSVファイルの読み込みや書き込みをする方法（open、reader、writer）
https://youtu.be/MjPHezbg9kM
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_167_p1.zip

CSVファイルを読み書きする方法を説明します。
パート1では、スニペットを使用して、CSVファイルを読み込む方法と書き込む方法を説明します。
スニペットとは、Pythonスクリプトの中で再利用できるコードのことで、テキストエディタとGeminiのprofessionalライセンスが必要です。
今回は、テキストエディタはメモ帳を使用します。
パート1では、パイソンスクリプトでスニペットを使用し、CSVファイルを読み込む方法と書き出す方法を説明します。
まず、CSVファイルを読み込んで、[出力]ウィンドウにデータを表示する方法を説明します。
CSVファイルのデータを確認します。
[csv read sample.csv]をダウンロードし、メモ帳で開きます。
CSVファイルには、4つのプロダクトIDと数字が記載されています。
Geminiのパイソンスクリプトでスニペットを使用し、csv read sample.csvを読み込みます。
Geminiを開きます。
ブロックを配置し、ブロックに対してパイソンスクリプトを作成します。
[モデリング]タブを開きます。
[コンポーネント]-[新規]を選択し、コンポーネントを作成します。
[ジオメトリ]-[フィーチャ]-[ブロック]を選択し、ブロックを作成します。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
3行目以下は不要なため、削除します。
スニペットを挿入したい場所にカーソルを置きます。
ツールバーの[スニペット]アイコンをクリック、もしくは、「Ctrl+J」のショートカットキーを使用します。
[_CsvRead]を記述、もしくは、スクロールして探します。
[_CsvRead]は、CSVファイルを読み込めるスニペットです。
[_CsvRead]を選択し、「Enter」キーを押す、もしくは、ダブルクリックします。
選択したスニペットのソースコードが挿入されます。
import csvは、CSVファイルを扱うためのメソッドを呼び出しています。
uriで、読み込みたいCSVファイルのパスを指定します。
「'」の中にパスをそのまま入れると、「\」や「バックスラッシュ」が改行などを意味する特別な文字だと思われてしまいます。
そのため、rを付けることで、通常の文字列と認識させています。
5行目～8行目で、指定したCSVファイルを開き、各行を読み込んだ後、[出力]ウィンドウに表示します。
6行目のdelimiterは、カンマ区切りでファイル内のデータを取得するよう指定しています。
uriにデフォルトで記述されているパスを削除します。
フォルダを開きます。
CSVファイルを右クリックし、パスをコピーします。
uriに貼り付けます。
ダブルクオーテーションは不要なため、削除します。
ファイルパスに日本語が入っている場合は、unicode関数を使用することで、読み込めます。
unicode_uri = unicode(uri)と記述し、パスをunicodeに変換します。
open関数の()の中をunicode_uriに変更します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、4つのプロダクトIDと数字が表示されています。
CSVファイルを読み込めたことがわかります。
なお、今回はCSVファイルがUTF8の文字コードで作成されていますが、UTF8以外のファイルはこのままでは読み込めません。
UTF8以外を読み込む場合は、import codecsとopen関数にcodecsを追記し、encodingでutf-16を指定するなど、ソースコードを修正してください。
パイソンスクリプトからCSVファイルにデータを書き込む方法を説明します。
3行目以下のソースコードをコメントアウトします。
スニペットを挿入したい場所にカーソルを置きます。
ツールバーの[スニペット]アイコンをクリック、もしくは、「Ctrl+J」のショートカットキーを使用します。
[_CsvWrite]を記述、もしくは、スクロールして探します。
[_CsvWrite]は、CSVファイルを書き込めるスニペットです。
[_CsvWrite]を選択し、「Enter」キーを押す、もしくは、ダブルクリックします。
選択したスニペットのソースコードが挿入されます。
17行目～21行目は、指定したCSVファイルを開き、書き込みたい内容を記述し、ファイルに書き込みます。
open関数の「wb」は、バイナリモードでファイルに書き込むよう指定しています。
19行目～21行目にデフォルトで、名前、苗字、年齢が1行ずつ書き込まれるソースコードが記述されています。
uriにCSVファイルの保存先を記述します。
uriにデフォルトで記述されているパスを削除します。
任意の保存先のパスをコピーし、貼り付けます。
ファイル名はcsv write sample.csvにします。
unicode_uri = unicode(uri)と記述し、パスをunicodeに変換します。
open関数の()の中をunicode_uriに変更します。
コンパイルボタンをクリックします。
uriで指定したフォルダを開きます。
CSVファイルが作成されていることがわかります。
CSVファイルをメモ帳で開くと、人名と年齢が表示されています。
CSVファイルにデータを書き込めたことがわかります。
説明は以上となりますが、配布している完成後のVCMXファイルは、URIを空欄にしているため、エラーが発生します。
そのため、動作確認する場合は、URIに任意のパスを指定した後、コンパイルボタンをクリックしてください。
スニペットを使用して、CSVファイルを読み込む方法と書き込む方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

CSVファイルを読み書きしよう(2/2)

パイソンスクリプト（Python）を使用して、読み込んだCSVファイルをシミュレーションに反映する方法と、シミュレーション結果をCSVファイルに書き込む方法（open、reader、writer）
https://youtu.be/o9rYcOENiDI
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_167_p2.zip

CSVファイルを読み書きする方法を説明します。
パート1では、スニペットを使用して、CSVファイルの読み込む方法と書き込む方法を説明しました。
パート2では、CSVファイルから読み込んだデータをシミュレーションに反映し、その結果をCSVファイルに書き込む方法を説明します。
CSVファイルを読み込んで、コンベア上のワークに情報を反映します。
[Import and export data with CSV files_Part2_before.vcmx]をダウンロードし、開きます。
3Dワールドにフィーダとコンベアが配置されています。
コンベアのプロセスを変更します。
中央に配置されているインラインコンベアを選択します。
[プロセス]タブを開きます。
[エディタ]-[プロセス]を選択し、プロセスを表示します。
[Inline Process]をクリックすると、「Inline Process」のダイアログが表示されます。
「Inline Process」にはデフォルトで、ワークがコンベアを出入りするときの動作が設定されていることがわかります。
[TransportIn]を選択します。
[ステートメントプロパティ]ウィンドウの[ソース]を[コンポーネントコンテナから]にします。
[TransportOut]を選択します。
[ステートメントプロパティ]ウィンドウの[目的地]を[コンポーネントコンテナへ]にします。
シミュレーション速度係数を2.0にします。
シミュレーションを実行します。
ワークが中央のコンベアで5秒間待機してから、右のコンベアに移動します。
シミュレーションをリセットします。
ワークの待機時間を変更します。
デフォルトのdelayを右クリックし、削除します。
delayを再度追加し、待機時間の定義を変更します。
[ステートメント]ボタンをクリックし、[その他のステートメント]-[ディレイ]を追加します。
delayをState: Busyの下に移動します。
[ステートメントプロパティ]ウィンドウの[分布]で、待機時間の定義を変更します。
プラスボタンをクリックします。
[分布]で[一様]を選択します。
[最小]に1、[最大]に10を入力します。
一様分布は、指定した範囲内のすべての値が等しい確率で発生する分布のことです。
今回は、1秒～10秒までのいずれかの秒数で遅延が起きるということになります。
インラインプロセスのダイアログを閉じます。
シミュレーションを実行します。
ワークが中央のコンベアで1秒～10秒までのいずれかの秒数で待機してから、右のコンベアに移動します。
シミュレーションをリセットします。
最初にワークが流れてくるコンベアに対して、同時に存在できるワークの数を変更します。
左のコンベアを選択します。
[コンポーネントプロパティ]ウィンドウの[Advanced]-[ConveyorCapacity]が9999になっています。
処理を見やすくするため、3に変更し、ワークが同時に3つまで存在できるようにします。
CSVファイルを読み込み、ワークにプロダクトIDとマテリアルを割り当てます。
[information to stamp.csv]をダウンロードし、メモ帳で開きます。
CSVファイルには、4つのプロダクトIDとマテリアルの色が記載されています。
パイソンスクリプトを使用して、コンベア上のセンサーがトリガされたときに、CSVファイルの情報が読み込まれるように設定します。
まずは、センサーの信号とパイソンスクリプトを接続します。
[モデリング]タブを開きます。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
[コンポーネントグラフ]ウィンドウの[SensorSignal]を選択します。
[プロパティ]ウィンドウの[接続]をクリックします。
プラスボタンをクリックすると、[Add Connections items]ダイアログが開きます。
[PythonScript]を選択します。
[接続]を確認すると、PythonScriptが追加されていることがわかります。
[Add Connections items]ダイアログを閉じます。
パイソンスクリプトを使用して、CSVファイルを読み込みます。
パイソンスクリプトを開きます。
ソースコードを削除します。
[PythonScriptCode1.txt]をダウンロードし、開きます。
ソースコードをコピーし、パイソンスクリプトに貼り付けます。
1行目～6行目は、8行目以下のソースコードを処理するための準備を行っています。
6行目は、先ほど設定したSensorSignalのビヘイビアを取得しています。
OnStart関数内では、シミュレーション実行時の動作を設定しています。
9行目～11行目は、CSVから読み込んだIDとマテリアルを格納するリストを作成しています。
また、処理されたパーツの数をカウントするための変数があり、初期値を0にしています。
uriにCSVファイルのパスを記述します。
[information to stamp.csv]のファイルパスをコピーし、uriに貼り付けます。
13行目でファイルパスをunicodeに変換します。
14、15行目でCSVファイルを開き、読み込みます。
16行目で、ヘッダー行、つまり、CSVファイルの1行目の読み込みをスキップします。
17行目～19行目で、CSVファイルの各行を読み込み込んだ後、製品IDと材料をリストに追加します。
OnSignal関数では、センサー信号を受け取ったときの動作を設定しています。
22行目は、処理されたパーツの数をカウントするための変数です。
23行目からコンベア上のSensorSignalがワークを検知したときの処理を記述しています。
24行目は検知したワークを取得しています。
25行目～27行目で、ワークのID、マテリアル、シミュレーション時間のプロパティを取得しています。
28行目～32行目で、プロパティがない場合、プロパティを作成します。
33行目からCSVデータの行数と同じ数だけ、ワークに対して、シミュレーション時間の設定、CSVから読み込んだ製品IDとマテリアルを設定します。
37行目で、処理したワークの数をカウントしています。
コンパイルボタンをクリックします。
シミュレーションを実行します。
コンベア上に流れてくるワークに対して、CSVファイルで設定したマテリアルが適用されていることがわかります。
4つのワークが流れてきたら、シミュレーションを一時停止します。
先頭のワークをダブルクリックします。
[コンポーネントプロパティ]ウィンドウを確認すると、[マテリアル]にwhite、[Procuct ID]に111、[Simulation time]に4.5が入力されています。
CSVファイルのIDとマテリアルが読み込まれ、各ワークに適用されていることがわかります。
また、センサーをトリガーしたときのシミュレーション時間が取得できていることがわかります。
シミュレーションをリセットします。
CSVファイルに情報を書き込みます。
プロダクトID、マテリアル、パススルー時間をCSVに書き込みます。
パススルー時間とは、ワークが1番目のセンサーをトリガーした時間と、2番目のセンサーをトリガーした時間の差です。
パススルー時間をCSVファイルに書き出すため、2番目のセンサーコンベアにパイソンスクリプトを作成します。
右のコンベアを選択します。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
[コンポーネントグラフ]ウィンドウの[SensorSignal]を選択します。
[プロパティ]ウィンドウの[接続]をクリックします。
プラスボタンをクリックすると、[Add Connections items]ダイアログが開きます。
[PythonScript]を選択します。
[接続]を確認すると、PythonScriptが追加されていることがわかります。
[Add Connections items]ダイアログを閉じます。
パイソンスクリプトを使用して、CSVファイルを読み込みます。
パイソンスクリプトを開きます。
ソースコードを削除します。
[PythonScriptCode2.txt]をダウンロードし、開きます。
ソースコードをコピーし、パイソンスクリプトに貼り付けます。
1行目～9行目は、11行目以下のソースコードを処理するための準備を行っています。
6行目は、先ほど設定したSensorSignalのビヘイビアを取得しています。
7行目は、CSVに書き込むID、マテリアル、パススルー時間の変数を初期化しています。
8行目のuriにCSVファイルを保存したいパスを記述します。
ファイル名はstatistics.csvにします。
9行目でファイルパスをunicodeに変換します。
OnStart関数内では、シミュレーション実行時の動作を設定しています。
12行目～14行目で、指定したCSVファイルを開き、ProductID、Material、PassThroughTimeという名前のヘッダー行を書き込みます。
OnSignal関数では、センサー信号を受け取ったときの動作を設定しています。
17行目は、ワークのID、マテリアル、パススルー時間の変数です。
18行目からコンベア上のSensorSignalがワークを検知したときの処理を記述しています。
19行目は検知したワークを取得しています。
20行目から、シミュレーション時間とIDのプロパティが取得できたときの処理を記述します。
21～23行目で、パススルー時間を計算しています。
24行目と25行目で、ワークのIDとマテリアルの名前を取得しています。
26行目～28行目で、CSVファイルを開いて、取得したID、マテリアル、パススルー時間を書き込みます。
コンパイルボタンをクリックします。
シミュレーションを実行します。
4つのワークが最後のコンベアを通り過ぎたら、シミュレーションを一時停止します。
uriで指定したフォルダを開きます。
CSVファイルが作成されていることがわかります。
CSVファイルをメモ帳で開くと、ワークのID、マテリアル、パススルー時間が表示されています。
CSVファイルにデータを書き込めたことがわかります。
説明は以上となりますが、配布している完成後のVCMXファイルは、URIを空欄にしているため、エラーが発生します。
そのため、動作確認する場合は、URIに任意のパスを指定した後、コンパイルボタンをクリックしてください。
CSVファイルから読み込んだデータをシミュレーションに反映し、その結果をCSVファイルに書き込む方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

eカタログにオリジナルモデルを登録しよう

eカタログにオリジナルの装置やレイアウトのモデルを登録する方法
関連動画：コンポーネントを保存しよう
https://youtu.be/UyNS6gIYY1k
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_108.zip

オリジナルモデルをeカタログに登録する方法を説明します。
本動画で説明する設定をしたオリジナルモデルは、設定を行ったパソコン上のeカタログにのみ反映されます。
eカタログは、[タイプ別モデル]と[製造者別モデル]にカテゴリー分けされています。
新しいカテゴリーを追加します。
[ホーム]タブを表示します。
[eカタログ]ウィンドウの、[コレクション]の右側にあるプラスアイコンをクリックします。
[ソースを編集]を選択します。
[ソース]ウィンドウの[新しいソースを追加]をクリックします。
[ソースを追加]ウィンドウの[ローカルソースを選択してください]をクリックします。
[ファイルまたはフォルダーの参照]ウィンドウが表示され、新規カテゴリーとして使用する場所を選択できます。
デスクトップに新しいフォルダーを作成するため、[デスクトップ]を選択します。
[新しいフォルダーを作成]をクリックすることで、選択した場所に新しいフォルダーを作成できます。
[新しいフォルダー]上で、右クリックし、メニューを開きます。
[名前の変更]を選択し、フォルダー名を[OriginalModel]に変更します。
[フォルダー(F):]を確認すると、変更したフォルダー名が反映されていません。
[OriginalModel]の選択を1度解除し、再度選択します。
[フォルダー(F):]に、[OriginalModel]の場所が表示されることを確認します。
[ネットワーク]内の任意のフォルダーを選択する、または[フォルダー(F):]に直接パスを入力することで、ネットワーク上の共有フォルダーを登録することもできます。
[OK]をクリックします。
[ソース]ウィンドウに、[OriginalModel]が追加されたことを確認します。
[閉じる]をクリックします。
[eカタログ]ウィンドウに、[OriginalModel]が追加されたことを確認します。
eカタログの[OriginalModel]に、モデルを登録します。
モデル単体を登録する場合、モデルをコンポーネントとして保存する必要があります。
モデルをコンポーネントとして保存する方法は、動画「コンポーネントを保存しよう」を参照してください。
eカタログにレイアウトを登録する方法を説明します。
付属ファイル[Chairs.vcmx]を開きます。
画面左下にある[セルグラフ]をクリックします。
[セルグラフ]ウィンドウで、Chairが3つあることを確認します。
Chairが3つ並んでいる現在のレイアウトを、eカタログに登録します。
レイアウトを登録するため、[ファイル]タブをクリックします。
[名前を付けて保存]を選択します。
[基本情報]の[プロジェクト名]を変更することで、eカタログに表示する名前を設定できます。
[プロジェクト名]は、Chairsです。
レイアウトを保存する場所を指定するため、[参照]をクリックします。
eカタログに登録したフォルダー[OriginalModel]を選択します。
[保存]をクリックします。
eカタログにChairsが追加されたことを確認します。
3Dワールドに配置し、Chairsを確認します。
コントロールキーとNキーを同時に押すことで、3Dワールドに配置されているモデルをすべて削除できます。
[変更点を保存しますか]とメッセージが表示された場合、[保存しない]を選択します。
[eカタログ]ウィンドウの[OriginalModel]を選択します。
Chairsをダブルクリックします。
レイアウトとして登録した場合、モデル内部の設定だけでなく、モデル同士の位置関係まで保存できます。
eカタログに登録したフォルダーの、登録を解除する方法について説明します。
[eカタログ]ウィンドウ、[コレクション]の右側にある、プラスアイコンをクリックします。
[ソースを編集]を選択します。
[ソース]ウィンドウの[OriginalModel]の右側にある[削除]をクリックします。
[閉じる]をクリックし、[ソース]ウィンドウを閉じます。
[eカタログ]ウィンドウから、[OriginalModel]が削除されたことを確認します。
オリジナルのモデルをeカタログに登録する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

IOコントロールウィザードを使用してリフトを作ってみよう(1/2)

オリジナルのリフト装置を作成する方法
（3DCADファイルをインポート、機構付け）
https://youtu.be/1-HcFap1WUQ
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_104_p1.zip

ウィザード機能を使用して、可動部をシグナルで制御する設定を、自動的に追加する方法について説明します。
シグナルで制御されたリフトを作成します。
設定が完了すると、上下、前後に動作するリフトが完成します。
本動画では、リフトをインポートし、可動部を設定します。
[ホーム]タブ、または[モデリング]タブをクリックします。
[インポート]グループの[ジオメトリ]をクリックすることで、CADファイルをインポートできます。
[Lift.3ds]を選択し、[開く]をクリックします。
[モデルをインポート]ウィンドウでは、インポート時のプロパティを設定できます。
[構造]は、モデルの分割方法を設定できます。
[フィーチャ]は、分割せず、[ノード]は、ジオメトリをすべて別のノードに分割します。
[コンポーネント]は、ジオメトリをすべて別のコンポーネントに分割します。
単一のモデルをインポートする場合、[フィーチャ]か[ノード]を選択します。
レイアウトをインポートする場合、[コンポーネント]を選択します。
[Lift.3ds]は、単一のモデルとしてインポートするため、[フィーチャ]を選択します。
3Dワールドに表示されるモデルは、多数の三角形で構成されており、[テッセレーションの品質]は、三角形の個数を設定できます。
モデルのデータ量に応じて品質を変更します。
低品質にすることで、モデルのデータ量を削減できます。
今回のモデルはデータ量が少ないため、[中位品質]に設定します。
[含める]では、インポート時のジオメトリに含む要素を設定できます。
今回は、[マークアップ]と[マテリアル]と[テクスチャー]を選択します。
[マテリアル作成ルール]では、マテリアルライブラリを作成するためのルールを設定できます。
今回は、[常にライブラリから最も近似のものを使用します]を選択します。
[フィーチャツリー]は、フィーチャツリーの作成方法を、設定できます。
[完全]は、CADファイルの階層構造をベースにし、すべてのジオメトリをトランスフォームフィーチャにいれ、フィーチャツリーを作成します。
CADファイルと完全に階層構造を一致させる場合、[完全]を選択します。
[最適化]は、すべてのジオメトリを同じ階層にし、[最小化]は、ジオメトリを1つにまとめることができます。
リフトの可動部を設定しやすくするため、フィーチャツリーをシンプルな状態にします。
[最適化]を選択します。
[ジオメトリを整理]では、ジオメトリセットを作成するルールを設定できます。
ジオメトリセットは、フィーチャツリーの各ジオメトリの中に含まれるジオメトリのまとまりです。
メッシュを構成する三角ポリゴンの3点の合計が10000を超えると、新しいジオメトリセットが作成されます。
[面による]は、面ごとに、[マテリアルによる]は、マテリアルごとにジオメトリセットを作成します。
[折りたたみ]は、ジオメトリセットを1つにまとめ、[数学的データ]は、曲線のジオメトリセットを作成します。
今回は、[マテリアルによる]を選択します。
[上軸]は、ジオメトリの上面と底面を整列させる軸を設定できます。
[上軸]で[-X]を選択し、[インポート]をクリックします。
リフトのCADファイルをインポートできます。
リフトの可動部を設定するため、[モデリング]タブを開きます。
上下に動作する可動部を設定します。
3Dワールドで、リフトの青い部分をすべて選択します。
コントロールキーを押した状態で、選択することで、複数のジオメトリを選択できます。
右クリックして、メニューを開きます。
[抽出]から[抽出リンク]を選択することで、選択したジオメトリを新しいノードに抽出できます。
[コンポーネントグラフ]ウィンドウに、「Link_1」が追加されたことがわかります。
Link_1に動作の詳細を設定します。
[リンクプロパティ]ウィンドウで、[JointType]を設定することで、動作の種類を定義できます。
[固定]は、動作を設定せず、ノードを定義した位置に固定できます。
[回転]は、定義した軸を中心に回転運動、[直進]は、軸に沿って直線運動できます。
[回転フォロワー]は、別のノードの運動量と連動した回転運動ができます。
[直進フォロワー]も[回転フォロワー]と同様に、別のノードと連動した直線運動です。
[カスタム]は、定義した軸を基準に、回転または直線運動できます。
今回は、[直進]を選択します。
可動部が動作する方向を設定します。
[軸]で+Zを選択します。
[軸]で選択する方向は、3Dワールドではなく、ノード自体の方向です。
[リンクプロパティ]ウィンドウの、[座標]の右側にある[オブジェクト]を選択することで、選択しているノードの方向を確認できます。
可動部が動作する方向を確認します。
[マニピュレーション]グループの[インタラクティブ]を選択することで、可動部の動作を確認できます。
3Dワールドで、「Link_1」をドラッグします。
「Link_1」が、Z軸方向に動作することがわかります。
シミュレーションのリセットボタンをクリックすることで、可動部が初期位置に戻ります。
[リンクプロパティ]ウィンドウの[Controller]は、ノードの動作を制御するコントローラーを定義できます。
[Controller]をクリックし、「新規サーボコントローラ」を選択します。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]を展開すると、サーボコントローラが追加されていることがわかります。
Geminiのサーボコントローラは、一般的なサーボコントローラとは異なり、可動部を制御する仮想のコントローラーを意味します。
[リンクプロパティ]ウィンドウの[初期値]は、ノードの初期位置、[J1]は、ノードの現在位置を表示しています。
現在、[初期値]と[J1]は0です。
[最小リミット]と[最大リミット]は、ノードが動作できる範囲の最小値と最大値を定義できます。
[最小リミット]と[最大リミット]を空白にすることで、動作できる範囲を制限しないこともできます。
今回は、[最小リミット]を0、[最大リミット]を700に設定します。
3Dワールドで、「Link_1」をドラッグします。
「Link_1」が、[最小リミット]と[最大リミット]の範囲外に動作すると、[リンクプロパティ]ウィンドウの[J1]にエラーが発生します。
範囲外に動作しない設定にする場合、[プログラム]タブをクリックし、[リミット]グループの[リミットで停止]にチェックを付けます。
[モデリング]タブをクリックします。
3Dワールドで、「Link_1」をドラッグします。
「Link_1」は、範囲外に動作しません。
リセットボタンをクリックします。
前後に動作する可動部を設定します。
3Dワールドで、リフトの灰色の部分を選択します。
右クリックして、メニューを開きます。
[抽出]から[抽出リンク]を選択します。
[コンポーネントグラフ]ウィンドウに、「Link_2」が追加されたことがわかります。
Link_2に動作の詳細を設定します。
リフトに前後動作を設定するため、[リンクプロパティ]ウィンドウで、[JointType]を「直進」、[軸]を「+X」に設定します。
既存のノードとは、異なるタイミングで動作できるようにするため、[Controller]をクリックし、「新規サーボコントローラ」を選択します。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]に、「サーボコントローラ_2」が追加されたことがわかります。
Link_2に可動範囲を設定します。
[リンクプロパティ]ウィンドウで[最小リミット]を0、[最大リミット]を300に設定します。
3Dワールドで、「Link_2」をドラッグします。
「Link_2」が、X軸方向に動作することがわかります。
3Dワールドで、「Link_1」をドラッグします。
「Link_2」は、「Link_1」の動作に追従しないため、追従するように設定します。
リセットボタンをクリックします。
[コンポーネントグラフ]ウィンドウの「Link_2」を、シフトキーを押した状態で、Link_1にドラッグ＆ドロップします。
シフトキーを押し忘れてジオメトリが移動した場合、シフトキーを押さずにドラッグ＆ドロップで、元のノードに戻すことで、ジオメトリの位置が戻ります。
新しいノードを追加するとき、[コンポーネントグラフ]ウィンドウの「Link_1」を選択し、[構造]グループの[リンクをクリエイト]をクリックすることで、自動的に「Link_1」の子階層に入れることもできます。
3Dワールドで、「Link_1」をドラッグします。
「Link_2」が、「Link_1」の動作に追従することがわかります。
リセットボタンをクリックします。
リフトの可動部を設定する方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

IOコントロールウィザードを使用してリフトを作ってみよう(2/2)

オリジナルのリフトを作成する方法
（ウィザードのIOコントロール、シグナル制御）
https://youtu.be/VhzljGrfMys
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_104_p2.zip

ウィザード機能を使用して、可動部をシグナルで制御する設定を、自動的に追加する方法について説明します。
本動画は、リフトの可動部を設定する方法の続きから設定します。
リフトの可動部が、設定完了しているファイル[Lift_after.vcmx]が必要です。
可動部をシグナルで制御する設定を自動的に追加します。
リフトを選択します。
[コンポーネントグラフ]ウィンドウで、Liftを選択します。
[追加]グループの[ウィザード]を展開し、[コンポーネントウィザード]から[IOコントロール]を選択します。
IOコントロールは、シグナルで可動部を制御する設定を、選択したコンポーネントに、自動的に追加する機能です。
[IOコントロール]ウィンドウで、詳細を設定します。
[入力シグナル]は、1つの可動部を制御するシグナルの数を定義します。
選択できるシグナルの数は、1から3です。
[Two Separate Signals]を選択します。
[J1]は、シグナルで制御する設定を可動部に追加するかを定義します。
[J1]にチェックを付け、可動部に設定を追加します。
[J1:CurrentState]は、J1の現在の状態を定義します。
Right、Left、Up、Down、Open、Closedから選択できます。
「Down」を選択します。
[J2]と[J2:CurrentState]は、2つ目の可動部に関する設定です。
[J2]にチェックを付け、[J2:CurrentState]で「Left」を選択します。
[適用]をクリックします。
[出力]ウィンドウには、追加完了と、[IOコントロール]ウィンドウを閉じてください、というメッセージが表示されます。
[IOコントロール]ウィンドウの[閉じる]をクリックします。
[コンポーネントグラフ]ウィンドウの[プロパティ]と[ビヘイビア]を展開し、追加された設定を確認します。
[プロパティ]の[J1_UpValue]は、「Link_1」が上昇完了する位置です。
[J1_DownValue]は、「Link_1」が下降完了する位置です。
それぞれの値は、「Link_1」の最大リミットと最小リミットを参照しています。
[J1_UpValue]は700mm、[J1_DownValue]は0mmです。
上昇、下降位置を変更する場合、プロパティの値を変更する必要があります。
[J1_MotionTime]は、「Link_1」の動作開始から完了までにかかる時間を設定できます。
[J1_MotionTime]が0秒の場合、「Link_1」は、[リンクプロパティ]の設定速度を参照します。
[J2_RightValue]は、「Link_2」が前進完了する位置です。
[J2_LeftValue]は、「Link_2」が後退完了する位置です。
[J2_MotionTime]は、「Link_2」の動作開始から完了までにかかる時間です。
[ビヘイビア]の[IN_J1_Up]が、ONの時、「Link_1」は上昇し、OFFの時は動作しません。
[IN_J1_Down]が、ONの時、「Link_1」は下降し、OFFの時は動作しません。
[OUT_J1_UpState]は、「Link_1」が上昇完了した時ONに、それ以外の位置にある時OFFに値が変化します。
[OUT_J1_DownState]は、「Link_1」が下降完了した時ONに、それ以外の位置にある時OFFに値が変化します。
[IN_J2_Right]が、ONの時、「Link_2」は前進し、OFFの時は動作しません。
[IN_J2_Left]が、ONの時、「Link_2」は後退し、OFFの時は動作しません。
[OUT_J2_RightState]は、「Link_2」が前進完了した時ONに、それ以外の位置にある時OFFに値が変化します。
[OUT_J2_LeftState]は、「Link_2」が後退完了した時ONに、それ以外の位置にある時OFFに値が変化します。
[IO_Controls_サーボコントローラ]と[IO_Controls_サーボコントローラ_2]は、「Link_1」と「Link_2」を制御しているPythonScriptです。
PythonScriptのプログラム内容を確認します。
[IO_Controls_サーボコントローラ]をダブルクリックします。
1行目から19行目までは、変数を定義しています。
21行目から40行目までは、[コンポーネントグラフ]ウィンドウの[プロパティ]と[ビヘイビア]を参照し、初期値を設定しています。
49行目から72行目までは、「Link_1」が動作する目標位置と、動作時間を設定しています。
75行目から97行目までは、入力シグナルを参照し、シグナルの名前によって目標位置を変更します。
100行目から116行目までは、出力シグナルの値を変更します。
119行目から127行目までは、「Link_1」を目標位置まで動作させます。
シミュレーションを実行します。
[コンポーネントグラフ]ウィンドウの[Lift]を選択します。
[接続]グループの[シグナル]を選択することで、シグナルエディタを表示できます。
シグナル名の右側にある丸をクリックすることで、シグナルのON/OFFを切り替えることができます。
丸がオレンジの場合OFF、緑の場合ONです。
[IN_J1_Up]をONに変更します。
リフトが上昇します。
上昇完了した時、OUT_J1_UpStateがONになることがわかります。
[IN_J1_Down]をONに変更します。
リフトは下降し、完了した時、OUT_J1_DownStateがONになることがわかります。
[IN_J2_Right]をONに変更します。
リフトは前進し、完了した時、OUT_J2_RightStateがONになることがわかります。
[IN_J2_Left]をONに変更します。
リフトは後退し、完了した時、OUT_J2_LeftStateがONになることがわかります。
シミュレーションをリセットします。
ウィザード機能を使用して、可動部をシグナルで制御する設定を、自動的に追加する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

Pythonのエラーを解決しよう

パイソンスクリプト（Python）を使用した際に発生するエラー（コンパイルエラー、実行時エラー）や例外を解決する方法
https://youtu.be/dK2Z872sRfI
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_071.zip

スクリプトのエラーを確認し、対処する方法を説明します。
動画内で使用するGeminiのファイルをダウンロードします。
ファイル名は、[ErrorManagementExample.vcmx]です。
ファイルを開くと、Geminiにコンポーネントが表示されます。
[出力]ウィンドウを確認すると、3Dワールドにコンポーネントをロードする際に発生したエラーが表示されています。
SyntaxError:invaild syntaxと記載されているため、構文に関するエラーが表示されていることがわかります。
Script line 13と記載されているため、エラーはScriptという名前のPythonスクリプトの13行目で発生していることがわかります。
対象のPythonスクリプトは、Error Management Exampleという名前のコンポーネントに含まれています。
エラーの内容は、「while」という単語のスペルミスです。
エラーの内容を確認できたため、Pythonスクリプトを修正します。
[モデリング]タブを開きます。
3Dワールドのコンポーネントを選択します。
[コンポーネント グラフ]ウィンドウの検索ボックスにScriptと入力します。
[Error Management Example]の[ビヘイビア]に[Script]が表示されるため、ダブルクリックして開きます。
13行目のwhieをwhileに修正します。
[出力]ウィンドウの表示エリアを右クリックし、clearを選択し、表示履歴を削除します。
コンパイルボタンをクリックします。
[出力]ウィンドウにエラーがないことを確認します。
シミュレーションを実行します。
[出力]ウィンドウを確認すると、シミュレーション実行中に発生したエラーが表示されています。
Script line 27と記載されているため、エラーはScriptの27行目で発生していることがわかります。
エラーの内容は、「ServoSensorSigna」という名前が定義されていないと記載されています。
エラーの内容を確認できたため、Pythonスクリプトを修正します。
シミュレーション実行中に、Pythonスクリプトを再度コンパイルできないため、シミュレーションをリセットします。
[Script]を開きます。
27行目のServoSensorSignaは、7行目でServoSensorSignalと定義されているため、タイプミスということがわかります。
27行目のServoSensorSignaをServoSensorSignalに修正します。
[出力]ウィンドウの表示履歴を削除します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
[出力]ウィンドウにエラーがないことを確認します。
シミュレーションをリセットします。
エラーが発生した際に対処する方法以外に、あらかじめエラーを考慮したスクリプトを記載する方法があります。
[Script]を開きます。
19行目～24行目までにtry-except文を記述し、例外処理をしています。
例外処理をすることで、try文の実行中にエラーが発生した場合でも、エラー箇所で処理が中断することなく、except文以降を実行できます。
今回は、10行目で使用している「Twist_DeleteMe」という名前のビヘイビアを削除し、20行目の記述でエラーを発生させます。
エラー発生後、24行目で「Twist_DeleteMeのビヘイビアにアクセスできません。例外処理を使用します。」という意味の文を[出力]ウィンドウに表示します。
シミュレーションを実行します。
エラーが発生していないため、try文のコードが実行され、青いブロックが前後に動きます。
シミュレーションを一時停止します。
[コンポーネント グラフ]ウィンドウの検索ボックスにTwistと入力します。
[Error Management Example]の[ビヘイビア]に[Twist_DeleteMe]が表示されるため、選択します。
右クリックし、「削除」ボタンを選択し、削除します。
シミュレーションをリセットします。
シミュレーションを再度実行すると、青いブロックは動作しません。
[出力]ウィンドウを確認すると、メッセージが表示されています。
Pythonスクリプトのtry文の実行中にエラーが発生し、except文が実行されたことがわかります。
スクリプトのエラーを確認し、対処する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

Pythonのスニペットを作成しよう

Pythonスクリプトの再利用可能なコードを作成する方法
https://youtu.be/VZLuGuRPbTI

Pythonスニペットを作成・編集する方法を説明します。
スニペットとは、Pythonスクリプトの中で再利用できるコードのことで、テキストエディタとGeminiのprofessionalライセンスが必要です。
今回は、テキストエディタはメモ帳を使用します。
まず、テキストエディタを開いてください。
ここではメモ帳を使用します。
app = getApplication()と記載し、Geminiの情報を取得します。
comp = getComponent()と記載し、Pythonスクリプトを設定しているコンポーネントを取得します。
この2つのメソッドはVC scriptから読みだしています。
スニペットを使用するときは、必ずこのメソッドとモジュールを記述してください。
ファイルを保存します。
ファイルを保存する前に、ドキュメントフォルダを開き、ファイル構成を確認します。
[ドキュメント]-[MITSUBISHI]-[Gemini]-[1.45]-[My Templates]-[Python Editor]-[Code Snippets]を開きます。
フォルダの[1.45]は[Gemini]のバージョンによって異なります。
今回は、GeminiのVer.1.45を使用するため、[1.45]を開きます。
[Code snippets]にスニペットを保存していきますが、デフォルトで複数のファイルがあります。
複数のファイルは、スニペットのファイルです。
ここにファイルを保存します。
メモ帳を開きます。
[ファイル]-[名前を付けて保存]をクリックし、[Code snippets]フォルダを選択します。
スニペットのファイル名を[example]、拡張子をPythonファイルの[.py]にし、保存します。
[ドキュメント]フォルダの[Code snippets]を開くと、[example.py]ファイルが保存されていることがわかります。
[Gemini]の[1.45]に保存したので、GeminiのVer.1.45でスニペットを使用できます。
スニペットの使用方法を説明します。
GeminiのVer.1.45を起動します。
[モデリング]タブの[コンポーネント]-[新規]を選択し、コンポーネントを作成します。
[ジオメトリ]-[フィーチャ]-[ブロック]を選択し、ブロックを作成します。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
パイソンスクリプトのダイアログが開くので、作成したスニペットを挿入します。
スニペットを挿入したい場所にカーソルを置きます。
ツールバーの[スニペット]アイコンをクリック、もしくは、「Ctrl+J」のショートカットキーを使用します。
[example]を選択し、「Enter」キーを押す、もしくは、ダブルクリックします。
コードが挿入されます。
このスニペットを実践的に使用できるよう編集します。
メモ帳でexampleファイルを開きます。
コンポーネントの中にあるパスを探すスニペットを記述していきます。
paths = comp.findBehavioursByType()と記述し、コンポーネントオブジェクトのビヘイビアを探します。
one way pathを探すので、VC_ONEWAYPATHと記述します。
これで、コンポーネント内のビヘイビアにあるone way pathのリストを返すことができます。
定数を覚えていない場合は、[ヘルプ]タブにアクセスすると、探すことができます。
[ヘルプと参照]から[パイソン API]をクリックします。
[目次]タブの中にある[Japanese]-[定数]をクリックします。
[ビヘイビア定数]をクリックし、スクロールしていくと、ビヘイビアタイプの名前を確認することができます。
ダイアログを閉じます。
メモ帳に戻ります。
スニペットを保存します。
GeminiのPythonスクリプトを開きます。
このスニペットを再度挿入すると、保存前のスニペットが表示されてしまうことがあります。
試しにスニペットを再度挿入すると、pathsが表示されていないことがわかります。
一度Pythonスクリプトのダイアログを閉じます。
再度Pythonスクリプトを開いて、元のスニペットを削除します。
再度スニペットを挿入します。
コンベアを使ってどのように動くかテストします。
Pythonスクリプトのダイアログを閉じます。
ctrl+nを押して、3Dワールドをクリアします。
[ホーム]タブに移動し、eカタログの[タイプ別モデル]-[Conveyors]を展開します。
[Visual Components]をクリックします。
[Conveyors]を追加します。
[モデリング]タブを開きます。
[動作設定]-[ビヘイビア]でPythonスクリプトを作成します。
10行目にスニペットを挿入します。
ショートカットの[control + J]を使用し、[example]を挿入します。
print pathsと記述し、[出力]ウィンドウに表示するテストをします。
コンパイルボタンをクリック、F9キーを押す、または、control+Sキーを押します。
[出力]ウィンドウに文字が表示されたことがわかります。
このコンポーネントには1つのone way pathがあるということがわかります。
Pythonスニペットを作成・編集する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

アクチュエータを作ってみよう(1/6)

オリジナルのアクチュエータの3DCADファイルをインポートして、可動部を1つ設定する方法
https://youtu.be/S8q0z61ybfM
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_075_p1.zip

オリジナルのアクチュエーターを作成する方法を説明します。
本動画では、アクチュエーターのモデルをインポートし、可動部を1つ設定する方法について説明します。
CADファイルをインポートします。
[ホーム]タブをクリックし、[インポート]グループの[ジオメトリ]をクリックすることで、CADファイルをインポートすることができます。
[Actuator.3ds]を選択し、[開く]をクリックします。
[モデルをインポート]ウィンドウでは、インポート時のプロパティを設定することができます。
[構造]は、単一のモデルをインポートする場合、[フィーチャ]か[ノード]を選択します。
レイアウトをインポートする場合、[コンポーネント]を選択します。
[Actuator.3ds]には、レイアウトとしてインポートする部分と、単一のモデルとしてインポートする部分があります。
コンポーネントとノードを設定しやすいように、ツリー構造をシンプルにするため、[フィーチャ]を選択します。
3Dワールドに表示されるモデルは、多数の三角形で構成されており、[テッセレーションの品質]は、三角形の個数を設定することができます。
データ量の多いモデルの場合、低品質にすることで、データ量を削減することができます。
今回はデータ量が少ないため、[中位品質]に設定します。
[含める]では、インポートするとき、ジオメトリに含む要素を設定することができます。
今回は、[マークアップ]と[マテリアル]と[テクスチャー]を選択します。
[マテリアル作成ルール]では、マテリアルライブラリを作成するためのルールを設定することができます。
今回は、[常にライブラリから最も近似のものを使用します]を選択します。
[フィーチャツリー]は、フィーチャツリーの作成方法を、設定することができます。
[完全]は、CADファイルの階層構造をベースにし、すべてのジオメトリをトランスフォームフィーチャに入れ、フィーチャツリーを作成します。
CADファイルと完全に階層構造を一致させる場合、[完全]を選択します。
[最適化]は、すべてのジオメトリを同じ階層にし、[最小化]は、ジオメトリを1つにまとめることができます。
アクチュエーターの可動部を設定するとき、フィーチャツリーをシンプルにするため、[最適化]を選択します。
[ジオメトリを整理]では、ジオメトリセットを作成するルールを設定することができます。
ジオメトリセットは、フィーチャツリーの各ジオメトリの中に含まれるジオメトリのまとまりです。
メッシュを構成する三角ポリゴンの3点の合計が10000を超えると、新しいジオメトリセットが作成されます。
面ごとにジオメトリセットを作成する場合、[面による]を選択し、マテリアルごとは、[マテリアルによる]を選択します。
ジオメトリセットを1つにまとめる場合、[折りたたみ]を選択し、曲線のジオメトリセットは、[数学的データ]を選択します。
今回は、[マテリアルによる]を選択します。
[上軸]は、ジオメトリの上面と底面を整列させる軸を設定することができます。
[上軸]で[-X]を選択し、[インポート]をクリックします。
アクチュエーター、ワークおよびテーブルのCADファイルをインポートすることができます。
ワークを、アクチュエーターとは別のコンポーネントに分けるため、[モデリング]タブを開きます。
緑のブロックをワークAとします。
3Dワールドで、ワークAを選択します。
右クリックして、メニューを開きます。
[抽出]から[コンポーネントを抽出]を選択することで、選択したジオメトリを新しいコンポーネントに抽出することができます。
コンポーネントの名前を、WorkAに変更します。
同様に、ワークAの下にある赤いブロックと、右側にある紫のブロックを別のコンポーネントに分けます。
赤いブロックをテーブルA、紫のブロックをテーブルBとします。
名前をTableAとTableBに変更します。
アクチュエーターの可動部を設定します。
アクチュエーターには、X軸方向に動作する可動部と、Z軸方向に動作する可動部と、Z軸を中心に回転する可動部と、ワークをつかむハンドがあります。
本動画では、X軸方向に動作する可動部を設定します。
アクチュエーターの黒い部分を選択します。
右クリックして、メニューを開きます。
[抽出]から[抽出リンク]を選択することで、選択したジオメトリを新しいノードに抽出することができます。
[コンポーネントグラフ]ウィンドウに、「Link_1」が追加されたことがわかります。
Link_1に動作の詳細を設定します。
[リンクプロパティ]ウィンドウで[JointType]を設定することで、動作の種類を定義することができます。
固定は、動作は設定せず、ノードを固定することができます。
回転は、定義した軸を中心に回転運動し、直進は、定義した軸に沿って直線運動することができます。
回転フォロワーは、別のノードの運動量に基づき、定義した軸を中心に回転運動し、変換フォロワーは、別のノードの運動量に基づき、直線運動することができます。
カスタムは、定義した軸を基準に、回転運動か直線運動することができます。
今回は、直進を選択します。
可動部が動作する方向を設定します。
[軸]で+Xを選択します。
可動部が動作する方向を確認します。
[マニピュレーション]グループの[インタラクティブ]を選択することで、可動部の動作を確認することができます。
3Dワールドで「Link_1」をドラッグします。
「Link_1」が、X軸方向に動作することがわかります。
シミュレーションのリセットボタンをクリックすることで、可動部が初期位置に戻ります。
[リンクプロパティ]ウィンドウの[Controller]は、ノードの動作を制御するコントローラーを定義することができます。
[Controller]をクリックし、「新規サーボコントローラ」を選択します。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]を展開すると、サーボコントローラが追加されたことがわかります。
Geminiのサーボコントローラは、一般的なサーボコントローラとは異なり、可動部を制御する仮想のコントローラーです。
[リンクプロパティ]ウィンドウの[初期値]はノードの初期位置、[J1]はノードの現在位置を表示しています。
現在、[初期値]と[J1]は0です。
[最小リミット]と[最大リミット]は、ノードの可動範囲の最小値と最大値を定義することができます。
[最小リミット]を0、[最大リミット]を1820に設定します。
ノードにサーボコントローラが設定されている場合、ノードを移動させるときの最大速度、最大加速度、最大減速度を設定することができます。
[リンクプロパティ]ウィンドウの[最大速度]に1000、[最大加速]に4000、[最大減速]に4000と入力します。
3Dワールドで「Link_1」をドラッグします。
「Link_1」が、[最小リミット]と[最大リミット]の範囲外に動作すると、[リンクプロパティ]ウィンドウの[J1]にエラーが発生します。
範囲外に動作しない設定にする場合、[プログラム]タブをクリックし、[リミット]グループの[リミットで停止]にチェックを付けます。
[モデリング]タブをクリックします。
3Dワールドで、「Link_1」をドラッグします。
範囲外に動作しないことを確認します。
リセットボタンをクリックします。
アクチュエーターのモデルをインポートし、可動部を1つ設定する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

アクチュエータを作ってみよう(2/6)

オリジナルのアクチュエータの、可動部を複数設定する方法
https://youtu.be/YC813yFBv0k
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_075_p2.zip

アクチュエーターの可動部を設定する方法について説明します。
本動画は、アクチュエーターのモデルをインポートし、可動部を1つ設定する方法の続きから設定します。
アクチュエーターのX軸方向の可動部のみ、設定完了しているファイル[Actuator1_after.vcmx]が必要です。
本動画では、Z軸方向に動作する可動部と、Z軸を中心に回転する可動部と、ワークをつかむハンドを設定します。
Z軸方向に動作する可動部を設定します。
アクチュエーターの灰色の部分をすべて選択します。
コントロールキーを押した状態で、選択をすることで、複数のジオメトリやコンポーネントを選択することができます。
右クリックして、メニューを開きます。
[抽出]から[抽出リンク]を選択し、新しいノードに抽出します。
[コンポーネントグラフ]ウィンドウに、「Link_2」が追加されたことがわかります。
Link_2に動作の詳細を設定します。
ワークをつかむとき、高さを調整するため、[リンクプロパティ]ウィンドウで[JointType]を「直進」、[軸]を「-Z」に設定します。
既存のノードとは、異なるタイミングで動作できるようにするため、[Controller]をクリックし、「新規サーボコントローラ」を選択します。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]に、サーボコントローラ_2が追加されたことがわかります。
「Link_2」の可動範囲を設定するため、[リンクプロパティ]ウィンドウの[最小リミット]を0、[最大リミット]を250に設定します。
ノードを移動させるときの最大速度、最大加速度、最大減速度を設定します。
[最大速度]に1000、[最大加速]に4000、[最大減速]に4000と入力します。
[マニピュレーション]グループの[インタラクティブ]を選択します。
3Dワールドで「Link_2」をドラッグします。
「Link_2」が、Z軸方向に動作することがわかります。
3Dワールドで「Link_1」をドラッグします。
「Link_2」は、「Link_1」の動作に追従しないため、「Link_1」の動作に追従するように設定します。
リセットボタンをクリックします。
[コンポーネントグラフ]ウィンドウの「Link_2」をシフトキーを押した状態で、ドラッグ＆ドロップし、Link_1に入れます。
シフトキーを押し忘れてジオメトリが移動した場合、シフトキーを押さずにドラッグ＆ドロップで、ノードから出すことで、ジオメトリを元の位置に戻すことができます。
新しいノードを追加するとき、[コンポーネントグラフ]ウィンドウの「Link_1」を選択した状態で、[構造]グループの[リンクをクリエイト]をクリックすることで、自動的に「Link_1」の子階層に入れることもできます。
3Dワールドで「Link_1」をドラッグします。
「Link_2」は「Link_1」の動作に追従することがわかります。
リセットボタンをクリックします。
Z軸を中心に回転する可動部を設定します。
ジオメトリを選択し、新しいノードへ抽出すると、回転運動の中心軸はコンポーネントの原点と同じ位置になります。
アクチュエーターの円形部品の中心を、回転運動の中心軸に設定するため、ジオメトリが設定されていないノードを作成します。
[コンポーネントグラフ]ウィンドウの「Link_2」を選択し、[構造]グループの[リンクをクリエイト]をクリックします。
「Link_2」の中に、ジオメトリが設定されていない「Link_3」が追加されたことがわかります。
「Link_3」の中心軸を、アクチュエーターの円形部品の中心に移動します。
[ツール]グループの[スナップ]を選択し、3Dワールドで目的の位置をクリックすることで、中心軸を移動することができます。
3Dワールドで、アクチュエーターの円形部品の中心をクリックします。
[リンクプロパティ]ウィンドウの[Offset]に、中心軸の位置が設定されたことがわかります。
Link_3に動作の詳細を設定します。
アクチュエーターを回転させるため、[JointType]を「回転」、[軸]を「+Z」に設定します。
既存のノードとは、異なるタイミングで動作できるようにするため、[Controller]をクリックし、「新規サーボコントローラ」を選択します。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]に、サーボコントローラ_3が追加されたことがわかります。
「Link_3」の可動範囲を設定するため、[リンクプロパティ]ウィンドウの[最小リミット]を0、[最大リミット]を180に設定します。
JointTypeが回転の場合、最小リミットと最大リミットは、回転角度の最小値と最大値を示します。
Link_3に、動作するジオメトリを設定します。
コントロールキーを押した状態で、アクチュエーターの水色の部分をすべて選択します。
選択したジオメトリは、[コンポーネントグラフ]ウィンドウのRoot[Actuator]でハイライトされます。
シフトキーを押した状態で、ハイライトされたジオメトリを[コンポーネントグラフ]ウィンドウのLink_3にドラッグ＆ドロップします。
3Dワールドで「Link_3」をドラッグします。
「Link_3」が、Z軸を中心に回転することがわかります。
3Dワールドで「Link_1」と「Link_2」をドラッグします。
「Link_3」は、「Link_1」と「Link_2」の動作に追従することがわかります。
リセットボタンをクリックします。
ワークをつかむハンドを設定します。
コントロールキーを押した状態で、ハンドの片側をすべて選択します。
右クリックして、メニューを開きます。
[抽出]から[抽出リンク]を選択し、新しいノードに抽出します。
[コンポーネントグラフ]ウィンドウに、「Link_4」が追加されたことがわかります。
同様に、ハンドの反対側も新しいノードに抽出します。
[コンポーネントグラフ]ウィンドウに、Link_5が追加されたことがわかります。
Link_4に動作の詳細を設定します。
ワークをつかむ動作をするため、[リンクプロパティ]ウィンドウで[JointType]を「直進」、[軸]を「+Y」に設定します。
既存のノードとは、異なるタイミングで動作できるようにするため、[Controller]をクリックし、「新規サーボコントローラ」を選択します。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]に、「サーボコントローラ_4」が追加されたことがわかります。
Link_4の可動範囲を設定するため、[リンクプロパティ]ウィンドウの[最小リミット]を0、[最大リミット]を10に設定します。
「Link_4」が、「Link_1」、「Link_2」、「Link_3」の動作に追従するように設定します。
[コンポーネントグラフ]ウィンドウの「Link_4」をシフトキーを押した状態で、ドラッグ＆ドロップし、Link_3に入れます。
3Dワールドで「Link_4」をドラッグします。
「Link_4」が、Y軸方向に動作することがわかります。
3Dワールドで「Link_1」、「Link_2」、「Link_3」をドラッグします。
「Link_4」が、どの動作にも追従することがわかります。
リセットボタンをクリックします。
Link_5に動作の詳細を設定します。
ワークをつかむとき、Link_4の動作に連動して、Link_4とは反対方向に動作するため、[リンクプロパティ]ウィンドウで[JointType]を変換フォロワー、[軸]を「-Y」に設定します。
[ドライバー]は、動作を連動させるために参照する別のノードの運動量を設定します。
[ドライバー]をクリックすることで、Link_1から4の運動量を選択することができます。
サーボコントローラ_4のJ4を選択します。
Link_5が、「Link_1」、「Link_2」、「Link_3」の動作に追従するように設定します。
[コンポーネントグラフ]ウィンドウのLink_5をシフトキーを押した状態で、ドラッグ＆ドロップし、Link_3に入れます。
3Dワールドで「Link_4」をドラッグします。
Link_5が、Link_4の動作に連動し、Link_4とは反対方向に動作することがわかります。
3Dワールドで「Link_1」、「Link_2」、「Link_3」をドラッグします。
Link_5は、どの動作にも追従することがわかります。
リセットボタンをクリックします。
アクチュエーターの可動部を設定する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

アクチュエータを作ってみよう(3/6)

オリジナルのアクチュエータの、ワークを検出する方法と、ワークを格納するコンテナの設定方法
https://youtu.be/KZdPoT9YzPc
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_075_p3.zip

アクチュエーターでワークを搬送するために必要な設定について説明します。
本動画は、アクチュエーターの可動部の設定方法の続きから設定します。
アクチュエーターのすべての可動部の設定が、完了しているファイル[Actuator2_after.vcmx]が必要です。
ワークを搬送するためには、コンポーネントに別のコンポーネントを格納することができる、コンテナという設定を使用します。
アクチュエーターと搬送先にコンテナを設定し、アクチュエーターのコンテナにあるワークを、搬送先のコンテナへ格納する必要があります。
ワークは、X・Z軸方向の移動と、回転動作に追従し、ハンドの開閉には追従しないため、Link_3にコンテナを設定します。
[コンポーネントグラフ]ウィンドウで「Link_3」を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[マテリアルフロー]から[コンポーネントコンテナ]を選択します。
同様に、テーブルBにコンテナを設定します。
テーブルBを選択します。
[動作設定]グループの[ビヘイビア]を展開し、[マテリアルフロー]から[コンポーネントコンテナ]を選択します。
ワークを搬送するプログラムを、パイソンスクリプトに記述します。
今回は、シミュレーション開始前からワークを配置していますが、シミュレーション開始後にワークを生成する場合もあります。
ワーク生成時にランダムな名前が付与されるため、ワークの情報を取得する必要があります。
ワークの情報を取得するため、ワークを検出するセンサーを設定します。
センサーの位置を設定します。
センサーの位置は、X軸方向・Z軸方向の移動、回転動作に追従して移動するため、Link_3に設定します。
アクチュエーターの水色の部分をダブルクリックすることで、「Link_3」のノードを選択することができます。
[ジオメトリ]グループの[フィーチャ]を展開し、[その他]から[フレーム]を選択します。
フレームは、3Dワールド上で、位置と方向を定義する基準点です。
3Dワールドに、フレームが表示されない場合、3Dワールドツールバーのフレームタイプを開き、フレームにチェックを付けます。
3Dワールドにフレームを表示することができます。
フレームを移動させるため、[ツール]グループの[スナップ]を選択します。
ワークをつかむとき、ワークとフレームが重ならないように注意します。
3Dワールドで、ハンドの中心をクリックします。
ワークを検出するため、センサーを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[センサー]から[レイキャスト]を選択します。
レイキャストセンサーは、定義したフレームの位置から光線を照射し、光線と交差したコンポーネントを検出することができます。
センサーの位置を、フレームを選択して、定義します。
[プロパティ]ウィンドウの[フレーム]をクリックし、フレームを選択することで、フレームの+Z軸方向に光線を照射することができます。
表示する光線の長さと、ワークを検出する範囲を設定します。
[最大範囲]は、3Dワールドに表示する光線の長さを設定し、[検出しきい値]は、コンポーネントを検出する範囲を設定することができます。
今回は、[最大範囲]と[検出しきい値]を50に変更します。
光線を非表示にするときは[光線表示]のチェックを外し、光線を表示するときは[光線表示]にチェックを付けます。
今回は、[光線表示]にチェックを付けます。
[コンポーネントシグナル]は、検出したコンポーネントを値として格納するシグナルを定義します。
センサーで検出したワークの情報を格納するため、シグナルを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[コンポーネント]を選択します。
コンポーネントシグナルは、コンポーネントを値として送受信することができます。
[コンポーネントグラフ]ウィンドウでRaycastSensorを選択します。
[プロパティ]ウィンドウの[コンポーネントシグナル]で、ComponentSignalを選択します。
ワークを搬送する場合、ワークがアクチュエーターのコンテナに格納された状態で、再度センサーでワークを検出し、テーブルのコンテナにワークを格納します。
ワークがアクチュエーターのコンテナに格納されている状態のとき、ワークはアクチュエーターのコンポーネント内にあります。
センサーはデフォルトの設定では、同じコンポーネント内にあるジオメトリを検出することはできません。
[親テスト]にチェックがついていない場合、RaycastSensorを含むコンポーネント以外のジオメトリのみを検出することができます。
[親テスト]にチェックを付けることで、RaycastSensorを含むコンポーネント内のジオメトリも検出することができます。
今回は、[親テスト]にチェックを付けます。
アクチュエーターが動作するタイミングを指示するため、シグナルを追加します。
[コンポーネントグラフ]ウィンドウで[Actuator]を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[ブール型]を選択します。
ブール型シグナルは、オンオフを送受信することができます。
名前をPositionAに変更します。
同様に、ブール型シグナルを7つ追加します。
名前は、PositionB、Up、Down、Rotate0、Rotate90、Open、Closeです。
PositionAがオンのとき、「Link_1」をテーブルAの位置、PositionBがオンのとき、「Link_1」をテーブルBの位置に移動します。
Downがオンのとき、「Link_2」をワークAの高さまで移動し、Upがオンのとき、「Link_2」を元の高さに戻します。
Rotate90がオンのとき、「Link_3」を90°回転し、Rotate0がオンのとき、「Link_3」を0°に戻します。
Openがオンのとき、ハンドを開き、Closeがオンのとき、ハンドを閉じます。
アクチュエーターの動作完了を通知するため、プロパティを追加します。
[プロパティ]グループの[プロパティ]を展開し、[ベーシック]から[ブール型]を選択します。
プロパティは、コンポーネントのグローバル変数であり、プログラム内のどこからでも使用することができます。
名前をX1に変更します。
同様に、ブール型プロパティを7つ追加します。
名前は、X2、X3、X4、X5、X6、X7、X8です。
X1はPositionAの動作が完了したとき、オンになります。
同様に、X2はPositionB、X3はUp、X4はDown、X5はRotate0、X6はRotate90、X7はOpen、X8はCloseの動作が完了したとき、オンになります。
本動画では、X1からX8の各状態を判別し、使用することはありません。
PLCと連携し、ラダー回路でアクチュエーターの動作を制御するときに使用するため、参考としてX1からX8を追加しています。
アクチュエーターでワークを搬送するために必要な設定についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

アクチュエータを作ってみよう(4/6)

オリジナルのアクチュエータの可動部の動作を、パイソンスクリプト（Python）で制御する方法
https://youtu.be/N9yJOhSm1xI
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_075_p4.zip

アクチュエーターの動作をパイソンスクリプトで制御する方法について説明します。
本動画は、アクチュエーターでワークを搬送するために必要な設定の続きから設定します。
アクチュエーターでワークを搬送するために必要な設定が、完了しているファイル[Actuator3_after.vcmx]が必要です。
本動画では、X軸方向の可動部である「Link_1」と、Z軸方向の可動部である「Link_2」を、パイソンスクリプトで制御します。
パイソンスクリプトを追加し、アクチュエーターを動作させるプログラムを記述します。
「Link_1」を動作させるためのパイソンスクリプトを追加するため、[コンポーネントグラフ]ウィンドウで「Link_1」を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
エディタが自動的に開くため、デフォルトで記述されているソースコードを1行目以外削除します。
パイソンスクリプトを含むコンポーネントの情報を取得するため、comp=getComponent()と記述します。
servo=comp.findBehaviourと記述することで、コンポーネントのビヘイビアを参照することができます。
カッコ内にサーボコントローラと記述し、名前を指定します。
シグナルを参照するため、posA=comp.findBehaviour("PositionA")と記述します。
同様に、ビヘイビアのPositionBを参照します。
変数名は、posBです。
X1a=comp.getPropertyと記述することで、コンポーネントのプロパティを参照することができます。
カッコ内にX1と記述し、名前を指定します。
同様に、プロパティのX2を参照します。
変数名は、X2aです。
def OnRun():と記述することで、シミュレーション開始時にプログラムを実行することができます。
アクチュエーターの初期状態と、プロパティの初期値を設定します。
シミュレーション開始と同時に、「Link_1」をテーブルAの位置まで移動します。
servo.moveJointと記述することで、サーボコントローラで制御しているノードを、指定した位置に移動することができます。
カッコ内に0,157と記述し、サーボコントローラのノードリストの0番目である「Link_1」を157の位置に移動します。
PLCと連携し、アクチュエーターの動作を制御する場合、アクチュエーターの状態を判別する必要があります。
[コンポーネントグラフ]ウィンドウのX1、X2は、アクチュエーターの「Link_1」の状態を示します。
X1がTrueのとき、「Link_1」がテーブルAの位置にある状態です。
X2がTrueのとき、「Link_1」がテーブルBの位置にある状態です。
シミュレーション開始時、「Link_1」はテーブルAの位置にあるため、X1aをTrue、X2aをFalseに設定します。
while True:と記述し、以下のプログラムをループさせます。
triggerCondition(lambda:getTrigger()==posA or getTrigger()==posB)と記述することで、posAかposBのオンオフが切り替わるまで、以下のプログラムを実行せず、待機することができます。
posAがTrueの場合、「Link_1」をテーブルAの位置に移動します。
X2a.Value=Falseと記述し、「Link_1」がテーブルBの位置にあることを示すX2をオフにします。
「Link_1」をテーブルAの位置に移動するため、servo.moveJoint(0,157)と記述します。
X1a.Value=Trueと記述し、「Link_1」がテーブルAの位置に移動完了したことを示します。
posBがTrueの場合、「Link_1」をテーブルBの位置に移動します。
X1a.Value=Falseと記述し、「Link_1」がテーブルAの位置にあることを示すX1をオフにします。
「Link_1」をテーブルBの位置に移動するため、servo.moveJoint(0,957)と記述します。
X2a.Value=Trueと記述し、「Link_1」がテーブルBの位置に移動完了したことを示します。
コンパイルをクリックします。
先程PythonScriptに記述したtriggerConditionで、PositionAとPositionBをトリガーとして使用するため、接続します。
[コンポーネントグラフ]ウィンドウのPositionAを選択します。
[プロパティ]ウィンドウの[接続]をクリックし、PythonScriptを選択します。
同様に、PositionBとPythonScriptを接続します。
「Link_2」を動作させるためのパイソンスクリプトを追加するため、[コンポーネントグラフ]ウィンドウで「Link_2」を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
PythonScript_2のプログラム内容は、PythonScriptと類似しているため、PythonScriptのプログラムをすべて選択し、コピーします。
PythonScript_2のプログラムをすべて選択し、貼り付けます。
PythonScript_2を編集します。
4行目で参照しているサーボコントローラの名前を、サーボコントローラ_2に変更します。
5行目の変数名をupに、参照しているシグナルの名前を、Upに変更します。
6行目の変数名をdownに、参照しているシグナルの名前を、Downに変更します。
7行目の変数名をX3aに、参照しているプロパティの名前を、X3に変更します。
8行目の変数名をX4aに、参照しているプロパティの名前を、X4に変更します。
アクチュエーターの初期状態と、プロパティの初期値を設定します。
「Link_2」は、シミュレーション開始と同時に移動させないため、11行目のservo.moveJoint(0,157)を削除します。
X3、X4の値は、アクチュエーターの「Link_2」の状態を示します。
X3がTrueのとき、「Link_2」が0の位置にある状態です。
X4がTrueのとき、「Link_2」がワークAの高さの位置にある状態です。
シミュレーション開始時、「Link_2」はワークAの高さにないため、X3aをTrue、X4aをFalseに設定します。
triggerConditionでトリガーとして使用するシグナルを、upとdownに変更します。
upがTrueの場合、「Link_2」を0の位置に移動します。
X4aをFalseに設定することで、「Link_2」がワークAの高さにないことを示します。
servo.moveJoint(0,0)に変更し、「Link_2」を0の位置に移動します。
X3aをTrueに設定することで、「Link_2」が0の位置に移動完了したことを示します。
downがTrueの場合、「Link_2」をワークAの高さに移動します。
X3aをFalseに設定することで、「Link_2」が0の位置にないことを示します。
servo.moveJoint(0,225)に変更し、「Link_2」を225の位置に移動します。
X4aをTrueに設定することで、「Link_2」がワークAの高さに移動完了したことを示します。
コンパイルをクリックします。
PythonScript_2に記述したtriggerConditionでUpとDownをトリガーとして使用するため、接続します。
[コンポーネントグラフ]ウィンドウでUpを選択します。
[プロパティ]ウィンドウの[接続]でPythonScript_2を選択します。
同様に、DownとPythonScript_2を接続します。
「Link_1」と「Link_2」の動作を確認するため、シミュレーションを実行します。
シミュレーション開始と同時に、「Link_1」がテーブルAの位置まで移動したことがわかります。
[接続]グループの[シグナル]をクリックし、アクチュエーターを選択することで、シグナルエディタを表示することができます。
PositionBをクリックしてオンにします。
「Link_1」がテーブルBの位置に移動したことがわかります。
PositionBをオフにして、PositionAをオンにします。
「Link_1」はテーブルAの位置に戻ります。
Downをクリックしてオンにします。
「Link_2」がワークAの高さまで移動したことがわかります。
Downをオフにして、Upをオンにします。
「Link_2」は元の高さに戻ります。
アクチュエーターの「Link_1」と「Link_2」の動作を、パイソンスクリプトで制御する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

アクチュエータを作ってみよう(5/6)

オリジナルのアクチュエータのワーク搬送を、パイソンスクリプト（Python）で制御する方法
https://youtu.be/xQSmuGiB5hQ
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_075_p5.zip

アクチュエーターの動作をパイソンスクリプトで制御し、ワークを搬送する方法について説明します。
本動画は、アクチュエーターの動作をパイソンスクリプトで制御する方法の続きから設定します。
アクチュエーターの可動部、「Link_1」と「Link_2」をパイソンスクリプトで制御する設定が、完了しているファイル[Actuator4_after.vcmx]が必要です。
本動画では、Z軸を中心に回転する可動部「Link_3」と、ワークをつかむハンド「Link_4」、「Link_5」をパイソンスクリプトで制御します。
パイソンスクリプトを追加し、アクチュエータを動作させるプログラムを記述します。
アクチュエーターがZ軸を中心に回転するためのパイソンスクリプトを追加するため、[コンポーネントグラフ]ウィンドウで「Link_3」を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
PythonScript_3のプログラム内容は、PythonScript_2と類似しているため、PythonScript_2のプログラムをコピーします。
[コンポーネントグラフ]ウィンドウのPythonScript_2を、ダブルクリックして開きます。
PythonScript_2のプログラムをすべて選択し、コピーします。
PythonScript_3のプログラムをすべて選択し、貼り付けます。
PythonScript_3を編集します。
4行目で参照しているサーボコントローラの名前を、サーボコントローラ_3に変更します。
5行目の変数名をrotate0に、参照しているシグナルの名前を、Rotate0に変更します。
6行目の変数名をrotate90に、参照しているシグナルの名前を、Rotate90に変更します。
7行目の変数名をX5aに、参照しているプロパティの名前を、X5に変更します。
8行目の変数名をX6aに、参照しているプロパティの名前を、X6に変更します。
プロパティの初期値を設定します。
PLCと連携し、アクチュエーターの動作を制御する場合、アクチュエーターの状態を判別する必要があります。
X5、X6の値は、アクチュエーターの「Link_3」の状態を示します。
X5がTrueのとき、「Link_3」が0°の状態です。
X6がTrueのとき、「Link_3」が90°の状態です。
シミュレーション開始時、「Link_3」は0°のため、X5aをTrue、X6aをFalseに設定します。
triggerConditionでトリガーとして使用するシグナルを、rotate0とrotate90に変更します。
rotate0がTrueの場合、「Link_3」が0°になるように回転します。
X6aをFalseに設定することで、「Link_3」が90°でないことを示します。
servo.moveJoint(0,0)で、「Link_3」が0°になるように回転します。
X5aをTrueに設定することで、「Link_3」が0°になったことを示します。
rotate90がTrueの場合、「Link_3」が90°になるように回転します。
X5aをFalseに設定することで、「Link_3」が0°でないことを示します。
servo.moveJoint(0,90)に変更し、「Link_3」が90°になるように回転します。
X6aをTrueに設定することで、「Link_3」が90°になったことを示します。
コンパイルをクリックします。
PythonScript_3に記述したtriggerConditionで、Rotate0とRotate90をトリガーとして使用するため、接続します。
[コンポーネントグラフ]ウィンドウでRotate0を選択します。
[プロパティ]ウィンドウの[接続]でPythonScript_3を選択します。
同様に、Rotate90とPythonScript_3を接続します。
ハンドに開閉する動作と、コンテナに格納するプログラムを記述し、ワークをつかみ、つかんでいるワークを放します。
ハンドの開閉動作をするためのパイソンスクリプトを追加するため、[コンポーネントグラフ]ウィンドウで「Link_4」を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
PythonScript_4のプログラム内容は、PythonScript_3と類似しているため、PythonScript_3のプログラムをすべて選択し、コピーします。
PythonScript_4のプログラムをすべて選択し、貼り付けます。
PythonScript_4を編集します。
4行目で参照しているサーボコントローラの名前を、サーボコントローラ_4に変更します。
5行目の変数名をopenに、参照しているシグナルの名前を、Openに変更します。
6行目の変数名をcloseに、参照しているシグナルの名前を、Closeに変更します。
7行目の変数名をX7aに、参照しているプロパティの名前を、X7に変更します。
8行目の変数名をX8aに、参照しているプロパティの名前を、X8に変更します。
ワークAの情報を取得するため、センサーで検出したコンポーネントを格納するシグナルを参照します。
signal=comp.findBehaviour("ComponentSignal")と記述します。
アクチュエーターの移動に、ワークを追従させるため、コンテナを参照します。
cont=comp.findBehaviour("ComponentContainer")と記述します。
搬送先のテーブルBのコンテナに、ワークAを格納するため、テーブルBを参照する必要があります。
パイソンスクリプトを含むコンポーネント以外のコンポーネントを参照する場合、まずGeminiのアプリケーションにアクセスします。
Geminiのアプリケーションにアクセスするため、app=getApplication()と記述します。
次に、参照するコンポーネントを指定します。
テーブルBを参照するため、tableB=app.findComponent("TableB")と記述します。
最後に、コンポーネント内の参照するビヘイビアを指定します。
コンテナを参照するため、cont2=tableB.findBehaviour("ComponentContainer")と記述します。
プロパティの初期値を設定します。
X7、X8の値は、アクチュエーターのハンドの状態を示します。
X7がTrueのとき、ハンドが開いている状態です。
X8がTrueのとき、ハンドが閉じている状態です。
シミュレーション開始時、ハンドは開いているため、X7aをTrue、X8aをFalseに設定します。
triggerConditionでトリガーとして使用するシグナルを、openとcloseに変更します。
openがTrueの場合、ハンドを開き、つかんでいるワークAを放します。
X8aをFalseに設定することで、ハンドが閉じていないことを示します。
センサーで検出したコンポーネントを、ワークAとして定義します。
ComponentSignalの値に検出したコンポーネントが格納されているため、workA=signal.Valueと記述します。
ワークAをテーブルBのコンテナに格納します。
grabメソッドを使用することで、コンテナやパスにコンポーネントを格納することができます。
cont2.grab(workA)と記述します。
servo.moveJoint(0,0)で、Link_4と、連動しているLink_5を0の位置に移動します。
X7aをTrueに設定することで、ハンドが開いたことを示します。
closeがTrueの場合、ハンドを閉じ、ワークAをつかみます。
X7aをFalseに設定することで、ハンドが開いていないことを示します。
servo.moveJoint(0,10)に変更し、Link_4と、連動しているLink_5を10の位置に移動します。
ワークAを定義するため、workA=signal.Valueと記述します。
cont.grab(workA)と記述し、アクチュエーターのコンテナにワークAを格納します。
X8aをTrueに設定することで、ハンドが閉じたことを示します。
コンパイルをクリックします。
PythonScript_4に記述したtriggerConditionで、OpenとCloseをトリガーとして使用するため、接続します。
[コンポーネントグラフ]ウィンドウでOpenを選択します。
[プロパティ]ウィンドウの[接続]でPythonScript_4を選択します。
同様に、CloseとPythonScript_4を接続します。
シミュレーションを実行します。
[接続]グループの[シグナル]をクリックし、アクチュエーターを選択することで、シグナルエディタを表示することができます。
Downをクリックしてオンにすることで、ワークAの高さまで移動します。
Closeをクリックしてオンにすることで、ハンドが閉じ、ワークAをつかみます。
Downをクリックしてオフにします。
Upをクリックしてオンにします。
ワークAは、アクチュエーターの動作に追従しているため、アクチュエーターのコンテナに格納されたことがわかります。
Rotate90をクリックしてオンにすることで、90度回転します。
Rotate90をクリックしてオフにします。
Rotate0をクリックしてオンにすることで、0度に戻します。
PositionBをクリックしてオンにすることで、テーブルBの位置まで移動します。
Upをクリックしてオフにします。
Downをクリックしてオンにすることで、ワークAを置く高さまで移動します。
Closeをクリックしてオフにします。
Openをクリックしてオンにすることで、ハンドが開き、ワークAを放します。
DownをオフにしてUpをオンにします。
ワークAは、アクチュエーターの動作に追従していないため、テーブルBのコンテナに格納されたことがわかります。
アクチュエーターの動作をパイソンスクリプトで制御し、ワークを搬送する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

アクチュエータを作ってみよう(6/6)

オリジナルのアクチュエータでワーク同士を結合する動作を、パイソンスクリプト（Python）で制御する方法
https://youtu.be/nge0I4F0UlE
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_075_p6.zip

アクチュエーターでワーク同士を結合する方法について説明します。
本動画は、アクチュエーターでワークを搬送するパイソンスクリプトの続きから設定します。
ワークを搬送するパイソンスクリプトの設定が、完了しているファイル[Actuator5_after.vcmx]が必要です。
茶色の箱をワークB、箱の下にある黄色のブロックとセンサーモデルをテーブルCとします。
センサーで検出したワークBのコンテナにワークAを格納することで、ワーク同士を結合します。
テーブルCを、アクチュエーターとは別のコンポーネントに分けます。
コントロールキーを押した状態で、テーブルCのジオメトリをすべて選択します。
右クリックして、メニューを開きます。
[抽出]から[コンポーネントを抽出]を選択します。
名前をTableCに変更します。
同様に、ワークBを別のコンポーネントに分けます。
名前をWorkBに変更します。
ワークAとワークBを結合するため、ワークBにコンテナを設定します。
[動作設定]グループの[ビヘイビア]を展開し、[マテリアルフロー]から[コンポーネントコンテナ]を選択します。
ワークBを検出するセンサーの位置を設定します。
センサーモデルを見やすくするため、ワークBを一旦非表示にします。
[コンポーネントグラフ]ウィンドウのWorkBを選択します。
[コンポーネントプロパティ]ウィンドウの[表示]からチェックを外すことで、コンポーネントを非表示にすることができます。
テーブルCをダブルクリックして、コンポーネントを選択します。
[ジオメトリ]グループの[フィーチャ]を展開し、[その他]から[フレーム]を選択します。
フレームをセンサーモデルの位置に移動します。
[ツール]グループから[スナップ]を選択し、センサーモデルの円形部品の中心をクリックします。
非表示にしたワークBを、再び表示します。
[ホーム]タブをクリックします。
[セルグラフ]ウィンドウで、WorkBの目玉アイコンをクリックすることで、コンポーネントを表示することができます。
ワークBを検出するため、センサーを追加します。
テーブルCを選択し、[モデリング]タブをクリックします。
[動作設定]グループの[ビヘイビア]を展開し、[センサー]から[レイキャスト]を選択します。
センサーの位置を、フレームを選択して、定義します。
[プロパティ]ウィンドウの[フレーム]をクリックし、フレームを選択します。
表示する光線の長さと、ワークBを検出する範囲を設定します。
[最大範囲]と[検出しきい値]を30に変更します。
センサーで検出したワークBの情報を格納するため、シグナルを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[コンポーネント]を選択します。
[コンポーネントグラフ]ウィンドウで、RaycastSensorを選択します。
[プロパティ]ウィンドウの[コンポーネントシグナル]で、ComponentSignalを選択します。
[ブールシグナル]は、コンポーネントを検出しているかを、シグナルのオンオフで通知することができます。
テーブルCにワークがあるか確認するため、ワークの検出を通知するシグナルを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[ブール型]を選択します。
本動画では、BooleanSignalの状態を判別し、使用することはありません。
PLCと連携し、ラダー回路でアクチュエーターの動作を制御するときに使用するため、参考としてBooleanSignalを追加しています。
[コンポーネントグラフ]ウィンドウで、RaycastSensorを選択します。
[プロパティ]ウィンドウの[ブールシグナル]で、BooleanSignalを選択します。
コンポーネントを検出したとき、BooleanSignalがオンに、検出していないとき、BooleanSignalがオフになります。
アクチュエーターの動作するタイミングを指示するシグナルを追加します。
アクチュエーターを選択し、[コンポーネントグラフ]ウィンドウの[Actuator]を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[ブール型]を選択します。
名前をPositionCに変更します。
PositionCがオンのとき、「Link_1」はテーブルCの位置に移動します。
PythonScriptには、シグナルをトリガーとして使用するため、TriggerConditionと記述されています。
PositionCをトリガーとして使用するため、PositionCとPythonScriptを接続します。
[プロパティ]ウィンドウの[接続]で、PythonScriptを選択します。
アクチュエーターの動作完了を通知するため、プロパティを追加します。
[プロパティ]グループの[プロパティ]を展開し、[ベーシック]から[ブール型]を選択します。
名前をX9に変更します。
X9はPositionCの動作が完了したとき、オンになります。
動作を追加するため、PythonScriptを編集します。
「Link_1」をテーブルCの位置に移動するため、[コンポーネントグラフ]ウィンドウでPythonScriptを開きます。
変数を定義します。
追加したシグナルを参照するため、posC=comp.findBehaviour("PositionC")と記述します。
追加したプロパティを参照するため、X9a=comp.getProperty("X9")と記述します。
追加したプロパティの初期値を設定します。
シミュレーション開始時、「Link_1」はテーブルAの位置にあるため、X9aをFalseに設定します。
triggerConditionでトリガーとして使用するシグナルに、posCを追加するため、or getTrigger()==posCと記述します。
posAがTrueの場合、「Link_1」はテーブルCの位置にないため、X9a.Value=Falseと記述し、X9をオフにします。
posBがTrueの場合も同様に、X9a.Value=Falseと記述します。
posCがTrueの場合、「Link_1」をテーブルCの位置に移動します。
X1a.Value=Falseと記述し、「Link_1」がテーブルAの位置にあることを示すX1をオフにします。
X2a.Value=Falseと記述し、「Link_1」がテーブルBの位置にあることを示すX2をオフにします。
「Link_1」をテーブルCの位置に移動するため、servo.moveJoint(0,1657)と記述します。
X9a.Value=Trueと記述し、「Link_1」がテーブルCの位置に移動完了したことを示します。
コンパイルをクリックします。
ワークAを置く高さを、変更するため、[コンポーネントグラフ]ウィンドウで、PythonScript_2を開きます。
servo.moveJoint(0,225)をservo.moveJoint(0,220)に変更します。
コンパイルをクリックします。
「Link_1」がテーブルCの位置まで移動した場合、ワークAとワークBを結合するため、PythonScript_4を編集します。
[コンポーネントグラフ]ウィンドウでPythonScript_4を開きます。
変数を定義します。
追加したプロパティを参照するため、X9a=comp.getProperty("X9")と記述します。
ワークBの情報を取得するため、センサーが設定されているテーブルCを参照する必要があります。
Geminiのアプリケーションには、すでにアクセスしているため、参照するコンポーネントを指定します。
テーブルCを参照するため、tableC = app.findComponent("TableC")と記述します。
ワークBの情報を取得するため、センサーで検出したコンポーネントを格納するシグナルを参照します。
signal2=tableC.findBehaviour("ComponentSignal")と記述します。
ハンドを開くとき、ワークAの定義後、ワーク同士を結合する記述を追加します。
X9aがTrueの場合、ワークAをワークBのコンテナに格納します。
テーブルCのセンサーで検出したコンポーネントをワークBとして定義するため、workB=signal2.Valueと記述します。
ワークBのビヘイビアを参照するため、cont3=workB.findBehaviourと記述します。
参照するビヘイビアの名前は、ComponentContainerです。
ワークBのコンテナにワークAを格納するため、cont3.grab(workA)と記述します。
ハンドを開くため、servo.moveJoint(0,0)と記述します。
X7a.Value=Trueと記述し、ハンドが開いたことを示します。
X9aがTrueではない場合、ワークAをテーブルBのコンテナに格納します。
cont2.grab(workA)からX7a.Value=Trueまでの3行を選択します。
タブキーを押し、インデントを1つ下げます。
コンパイルをクリックします。
シミュレーションを実行します。
[接続]グループの[シグナル]をクリックし、アクチュエーターを選択することで、シグナルエディタを表示します。
Down、Closeの順にクリックすることで、ワークAをつかみます。
Down、Upの順にクリックすることで、ワークを持ち上げます。
PositionCをクリックすることで、テーブルCの位置まで移動します。
Up、Downの順にクリックすることで、ワークAを置く高さまで移動します。
Close、Openの順にクリックすることで、ハンドを開き、ワークAを放します。
Down、Upの順にクリックします。
シミュレーション中に、ワーク同士を結合することで、ワークAとワークBを一緒に操作することができます。
[接続]グループの[シグナル]をクリックし、シグナルエディタを非表示にします。
ワークBをダブルクリックして、コンポーネントを選択します。
[コンポーネントプロパティ]ウィンドウの[表示]から、チェックを外します。
[表示]のチェックを外したワークBだけでなく、ワークBのコンテナ内にあるワークAも一緒に非表示になったことがわかります。
[コンポーネントプロパティ]ウィンドウの[表示]に、チェックを付け、ワークAとワークBを表示します。
[接続]グループの[シグナル]をクリックし、シグナルエディタを表示します。
シグナルをすべてオフにします。
Down、Close、Down、Upの順にクリックすると、ワークAのみ持ち上げます。
アクチュエーターのセンサーが、ワークAを検出しているため、ワークAのみつかむことができます。
アクチュエーターでワーク同士を結合する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ウィザードを使ってみよう

オリジナルの装置の動作設定を自動生成する方法
https://youtu.be/OuP0BmHoJrQ
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_004.zip

[ウィザード]を展開し、[マシン]を選択します。
[マシン]ウィンドウでは、サーボコントローラが設定されており、[ドアジョイント]はJ1、[現在の状態]はDoor is Openが選択され、
ドアが開いている状態を表しています。
プロセスモデルにチェックがついていることを確認します。
マシンウィザードの使用方法を説明します。
マシンウィザードは、マシンの設定をすることができるツールです。
シミュレーション対応のマシンに変換し、PLC接続、ワークライブラリ、およびプロセスモデリングで使用することができます。
[プロセス]タブに移動します。
3Dワールドに配置されているコンポーネントに、ワークを搬送する手順を設定しますが、
コンポーネントに動作設定がされていないので、シミュレーションを実行するための準備をするために、[モデリング]タブに移動します。
3DCADファイルから、インポートした状態のコンポーネントを設定します。
ワークステーションのコンポーネントグラフを展開し、設定を確認します。
ワークステーションのプロパティとビヘイビアには、何も設定されていません。
ルートフィーチャを確認することで、ワークステーションが1つのジオメトリであることが確認できます。
マシンボディも同様に確認します。
ワークステーションを選択し、[ウィザード]を展開します。
マシンは、選択したコンポーネントに、必要なプロパティ、動作、機能を追加することができます。
[マシン]をクリックします。
[マシン]ウィンドウで設定をすることで、プロセスモデリング、ワークライブラリ、またはPLC接続を使用するためのプロパティを追加することができます。
デフォルトの状態で、[適用]ボタンをクリックすることで、フレームとリンクが追加されました。
リンクを選択し、3Dワールドでドラッグし、ワークスターションのテーブル上に配置します。
[ProductLocationApproach]フレームは、ワークステーションに、ワークを投入する位置に移動し、
[ResourceLocation]フレームは、ワークを配置するため、人が停止する位置に移動します。
ワークステーションにある2つのフレームを選択します。
Ctrlキーを押し、2つのフレームを選択します。
座標をオブジェクト座標に変更します
人がワークを配置するとき、人が向く方向を設定するために、Z軸を中心に、反時計回りに90度回転させます。
人は、フレームのX軸が指し示す方向を向き、ワークを配置します。
eカタログの[PM Flow Components]から、[Feeder Process]と[Sink Process]を配置します。
プロセスモデルの使用方法がわからない場合は、ヘルプファイルを参照してください。
[エディタ]グループの中にある[フロー]をクリックし、ワークを搬送する順番を設定します。
使用するコントローラーのアイコンをクリックするので、Human Transport Controllerのアイコンをクリックします。
フィーダープロセスにカーソルを合わせ、表示される文字をクリックします。
ワークステーションにカーソルを合わせ、表示される文字をクリックします。
シンクプロセスにカーソルを合わせ、表示される文字をクリックします。
シミュレーションを実行しますが、動作しません。
コントローラーを選択し、[Connect All Resources]をクリックし、シミュレーションを実行します。
動作しない原因は、コントローラーと人を接続していなかったことです。
人などのリソースとコントローラは、eカタログのプロセスモデリングフォルダーから、配置することができます。
シミュレーションを実行します。
人が、フィーダーからワークを持ち上げ、ワークステーション、シンクの順番で搬送しました。
次に、マシンボディの設定をします。
マシンボディもワークステーション同様、3DCADファイルからインポートした状態です。
マシンボディに、ドアが開閉する設定をします。
ジオメトリを分割します。
ジオメトリを選択し、右クリックでメニューを開き、[エクスプロード]を選択することで、ジオメトリを分割することができます。
マシンボディのドアを、可動部に設定します。
3Dワールドで、Ctrlキーを押しながら、マシンの左側のドアを選択しましょう。
右クリックでメニューを開き、[抽出]、[抽出リンク]と選択します。
同様に、右側のドアを選択し、リンクを抽出しましょう。
作成したリンクは、コンポーネントグラフに表示されます。
リンク1の[リンクプロパティ]から、[JointType]を「変換」に設定し、[軸]に「+X」を設定することで、+X軸方向に直線運動します。
[Controller]で「新規サーボコントローラ」を選択し、コンポーネントグラフに新しいサーボコントローラを作成します。
ドアの可動域を設定するので、[最小リミット]は「0」、[最大リミット]は「550」です。
リンク2を選択します。
リンク2は、リンク1の運動量と連動し、リンク1とは反対側に動作するので、[JointType]は変換フォロワー設定します。
[軸]は「-X」に、[ドライバー]は「サーボコントローラ」の「J1」を設定します。
[インタラクティブ]コマンドをクリックし、可動域と動作を確認することができます。
マシンボディを選択し、[ウィザード]を展開し、[マシン]を選択します。
[マシン]ウィンドウでは、サーボコントローラが設定されており、[ドアジョイント]はJ1、[現在の状態]はDoor is Openが選択され、
ドアが開いている状態を表しています。
プロセスモデルにチェックがついていることを確認し、[適用する]をクリックします。
[出力]ウィンドウでは、フレームの移動場所を説明しています。
コンポーネントグラフには、プロセスノードというリンクが作成されます。
[移動]コマンドをクリックし、プロセスノードを、ワークを配置する位置に移動します。
[ProductLocationApproach]フレームが、[ResourceLocation]フレームの上に配置されていることを確認します。
ロボットがマシンに接近し、ワークを投入する位置です。
[プロセス]タブに移動します。
[フロー]コマンドをクリックし、ワークステーションとシンクをつなぐ矢印を、削除します。
ワークステーションからマシンボディに搬送し、マシンボディからシンクに搬送するフローを設定します。
コントローラーのアイコンをクリックし、ワークステーション、マシンボディ、シンクの順番で選択します。
マシンボディをクリックし、[ProcessTime]に値が設定されていることを確認します。
ワークがマシン内にとどまる時間を、変更することができます。
ワークステーションにも、[ProcessTime]があります。
シミュレーションを実行します。
ワークステーションからマシンボディに、ワークを搬送しますが、ワークを配置するとき、人がマシンボディの方向を向いていません。
修正するために、[モデリング]タブに移動します。
[ResourceLocation]フレームと、[ProductLocationApproach]フレームのX軸方向を、変更する必要があります。
Ctrlキーを押しながら、2つのフレームを選択し、
Z軸を中心に、反時計回りに90度回転させます。
シミュレーションを実行します。
[プロセス]タブに戻ります。
マシンボディの方向を向いた状態で、マシンボディにワークを配置しました。
マシンウィザードの使用方法についての説明は以上となります。

=================================================================================

ウィザードを使ってコンベアを作ってみよう

ウィザードを使ってオリジナルのコンベアを作る方法
https://youtu.be/nImoY3SGlbc
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_036.zip

コンベアをモデル化する方法を説明します。
CADファイルを3Dワールドにインポートします。
[ホーム]タブの[インポート]グループから[ジオメトリ]をクリックします。
ウィンドウからconveyor geometry.3DSを選択し、開くをクリックします。
[モデルをインポート]パネルの[フィーチャツリー]を「折りたたみ」、[上軸]を「-X」に設定します。
[インポート]をクリックしCADファイルを読み込みます。
インポートしたコンポーネントの名称はCADファイルの名称を引き継ぎます。
[コンポーネントプロパティ]パネルから[名前]を「Simple Conveyor」に変更します。
コンポーネントを保存します。
[モデリング]タブに移動し[コンポーネント]グループの[名前を付けて保存]をクリックします。
コンポーネントを[名前を付けて保存]パネル のタイプを「Conveyors」に設定し[名前をつけて保存]をクリックします。
保存先をマイ モデルフォルダに設定し[保存]をクリックします。
コンポーネント原点をコンベアの始端に変更します。
現状の原点位置からコンベアの始端までの距離を測定します。
[モデリング]タブの[ツール]グループから[測定]を選択します。
[測定]パネルのスナップタイプを「原点」に設定します。
コンベアをクリックすると原点位置が選択できます。
[測定]パネルの[スナップタイプ]を「エッジ」に変更します。
コンベア右側にある足の下側隅をクリックすると距離を測定できます。
測定結果は3Dワールド上の表示と[出力]ウィンドウで確認できます。
3Dワールドの何もないスペースをクリックし測定モードを終了します。
[原点]グループの[移動]をクリックします。
[原点を移動]パネルの[座標]を[親]に設定し、Xに-1031.601、Yに227.057を入力します。
[適用]をクリックすると原点位置を移動できます。
コンベアのジオメトリフィーチャをパーツごとに分解します。
[モデリング]タブの[ジオメトリ]グループから[ツール]をクリックし[スプリット]を選択します。
[スプリットフィーチャ]パネルの[スプリットレベル]を「設定」にします。
コンベアの始点にある最初のロールバーを選択します。
[スプリットフィーチャ]パネルの[スプリット]をクリックするとロールバーが新たなジオメトリフィーチャとして分割されます。
[フィーチャプロパティ]パネルから[名前]を「RollParts」に変更します。
サイドレールも同様に分割します。
[モデリング]タブの[ジオメトリ]グループから[ツール]をクリックし[スプリット]を選択します。
[スプリットフィーチャ]パネルの[スプリットレベル]を[設定]にします。
コンベアのサイドレールを選択し コントロールキーを押しながらもう一方のサイドレールを選択します。
[スプリットフィーチャ]パネルの[スプリット]をクリックするとサイドレールが新たなジオメトリフィーチャとして分割されます。
[フィーチャプロパティ]パネルから[名前]を「Side Rails」に変更します。
足も同様に分割します。
[モデリング]タブの[ジオメトリ]グループから[ツール]を クリックし[スプリット]を選択します。
[スプリットフィーチャ]パネルの[スプリット レベル]を[設定]にします。
コンベアの足を選択しコントロールキーを押しながら他の足を選択します。
[スプリットフィーチャ]パネルの[スプリット]をクリックすると足が新たなジオメトリフィーチャとして分割されます。
[フィーチャプロパティ]パネルから[名前]を「Legs」に変更します。
オリジナルの ジオメトリフィーチャであるCollapsed_0を削除します。
サイドレールの長さに応じてロールバーの数量を増減させる設定をします。
[コンポーネントグラフ]から「Simple Conveyor」を選択します。
[プロパティ]グループの[プロパティ]をクリックし実数のプロパティを追加します。
[プロパティ]パネルから名前を「CLength」、量「Distance」、値を1000、制約を1000-10000に設定します。
制約を設定することによりプロパティの値の範囲を制限できます。
[ジオメトリ]グループの[フィーチャ]から[直線クローン]を追加します。
[フィーチャプロパティ]パネルから[カウント]を「CLength / 100」、[ステップ]を100に設定します。
[カウント]は個数、[ステップ]は間隔を表しており、100mm間隔でロールバーを配置するため[カウント]を100で割っています。
[方向]の「Vector(1,0,0)」はXYZの順になっておりクローンで増減させたい方向に1を立てます。
フィーチャツリーで「RollBars」を「LinearClone」の配下になるように移動します。
ロールバーが複製されたことが確認できます。
SideRailを「CLength」の値に応じて伸縮させる設定をします。
フィーチャツリーのルートを選択した状態で[ジオメトリ]グループの[フィーチャ]から「トランスフォーム」を追加します。
[フィーチャプロパティ]パネルの数式に「Tx(100).Sx((CLength-200)/2800).Tx(-100)」と入力します。
フィーチャツリーで「SideRails」を「トランスフォーム」の配下になるように移動します。
SideRailの長さが変更されたことが確認できます。
足の位置をSideRailの伸縮に合わせて変更する設定をします。
[モデリング]タブの[ジオメトリ]グループから[ツール]をクリックし[スプリット]を選択します。
スプリットフィーチャパネルのスプリットレベルを設定にします。
コンベアの終端側の足を選択しコントロールキーを押しながらもう一方の終端側の足を選択します。
[スプリットフィーチャ]パネルの[スプリット]をクリックすると終端側の足が分解されます。
分割した終端側の足を削除します。
始端側の足を伸縮したSideRailの位置に合わせてクローンを使用して足を複製します。
[ジオメトリ]グループの[フィーチャ]から[直線クローン]を追加します。
[フィーチャプロパティ]パネルから[カウント]を2、[ステップ]を「CLength-100」に設定します。
フィーチャツリーで「Legs」を「LinearClone_1」の配下になるように移動します。
SideRailの長さに合わせて足が複製されたことが確認できます。
「CLength」の値を変更しRollBarの数、SideRailの長さ、足の位置が、自動的に更新されることを確認します。
コンベアウィザードによるコンベアの設定について説明します。
コンベアウィザードを使用するとコンベアの設定に必要な機能が自動作成されます。
[コンポーネントグラフ]からコンベアのコンポーネントを選択します。
[モデリング]タブの[追加]グループから[ウィザード]をクリックしコンベアを選択します。
[コンベア]パネルで[コンベヤーの動作を作成する]をクリックします。
ビヘイビアの中にパスとインターフェースが追加されたことが確認できます。
3Dワールドのツールバーから[フレームタイプ]を選択し[フレーム]にチェックを入れフレームを可視化します。
フィーチャツリーの「PathFrames_1」を選択します。
「PathFrames_1」は配下に存在するパスフレームに影響を与えるトランスフォームフィーチャとなります。
[フィーチャプロパティ]パネルで現在の「CLength」の値をウィザード使用時の「CLength」の値で割った値に応じてパスフレームをX軸に沿ってスケーリングする式を記述します。
ウィザード使用時の「CLength」の値が3000のため「Sx(CLength/3000)」と入力します。
「CLength」の値を変更した際に「PathFrames_1」始点のフレームがコンベアの始点に移動しない場合はX軸方向にオフセットする必要があります。
記述する式としては「Tx(-ウィザード使用時のCLengthの値/2+CLength/2).CLength/ウィザード使用時のCLengthの値」となります。
コンベアの設定が完了しました、
他のコンポーネントと接続し動作確認をします。
[ホーム]タブに移動します。
eカタログの[タイプ別モデル]を展開し[Feeders]を選択します。
[Shape Feeder]をダブルクリック、もしくはドラッグアンドドロップで3Dワールドに配置します。
PnPを選択しコンベアの始点側に接続します。
[コンポーネントプロパティ]パネルから[既定]タブを選択します。
プロダクトを「CollarPallet」に設定します。
eカタログの[タイプ別モデル]の[Conveyors]を展開し[Visual Components]を選択します。
コンベアを3Dワールドに配置します。
PnPを選択しコンベアの終点側に接続します。
[コンポーネントプロパティ]パネルから[既定]タブを選択します。
[ConveyorWidth]を800に設定します。
シミュレーションを再生しフィーダーから生成されたパレットがコンベア状を流れることを確認します。
シミュレーションをリセットします。
eカタログの[タイプ別モデル]の[Conveyor Utilities]を展開し[Visual Components]を選択します。
Conveyor Sensorを3Dワールドに配置しコンベアの中心に接続します。
センサは自動的にパスに接続されます。
コンベアをモデル化する方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

オリジナルのリニアトラックを作ってみよう(1/2)

オリジナルのリニアトラックを作成し、台車をリニアトラックに沿って動作可能にする方法
https://youtu.be/L3YAOI1OQEA
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_168_p1.zip

オリジナルのリニアトラックを作る方法を説明します。
リニアトラックとは、ロボットが移動するための単軸のレールのことです。
パート1では、リニアトラックのCADをインポートし、台車を動かす方法を説明します。
リニアトラックのジオメトリをインポートします。
[small_track.STEP]をダウンロードします。
[モデリング]タブを開きます。
[インポート]-[ジオメトリ]を選択します。
[small_track.STEP]を選択し、開きます。
[モデルをインポート]ウィンドウの[テッセレーションの品質]をスライドし、高品質にします。
[構造]は[フィーチャ]、[フィーチャツリー]は[完全]、[ジオメトリを整理]は[マテリアルによる]、[上軸]は[+Z]が選択されている状態にします。
[分析]を選択します。
約15479個の三角形があることがわかります。
[インポート]をクリックします。
コンポーネントが3Dワールドの中心に配置されない場合は、[コンポーネントプロパティ]ウィンドウの[X]と[Y]をクリックし 、Xの値とYの値を「0」に設定します。
原点を台車の中心に移動します。
[原点]-[移動]を選択します。
原点のXYZ軸の方向は、3Dワールドと一致しているため、今回は変更しません。
原点はレールの裏側の端に配置されています。
X軸の位置を台車の中央に移動します。
X軸の矢印を選択してドラッグします。
スナップするにはコントロールキーを押します。
反対側のエッジの中央にスナップすると、X 軸は台車の中央に配置されます。
Y軸はデフォルトで中心に配置されています。
[原点を移動]ウィンドウの[適用]をクリックします。
台車をリニアトラックから分離します。
[マニピュレーション]-[移動]が選択された状態で、リニアトラックを選択します。
[コンポーネントグラフ]ウィンドウの[ノードフィーチャツリー]を確認すると、コンポーネントが1つのフィーチャとして表示されています。
ハイライト表示されたフィーチャを右クリックし、[エクスプロード]を選択します。
[出力]ウィンドウを確認すると、67 個のサブフィーチャに分解されたことが表示されています。
プラスを選択すると、ツリーが展開され、サブフィーチャが表示されます。
3Dワールド上でリニアトラックをクリックすると、サブフィーチャが選択できます。
ジオメトリを分解するには、[ジオメトリ]-[ツール]-[スプリット]を選択する方法もあります。
コントロールキーを押しながら、台車のジオメトリを全て選択します。
3Dワールド上で台車を右クリックし、[抽出]-[抽出リンク]を選択します。
[コンポーネントグラフ]ウィンドウを確認すると、[link_1]が表示されています。
台車をレールから分離できたことがわかります。
台車のジョイントを設定します。
[コンポーネントグラフ]ウィンドウの[link_1]が選択された状態で、[リンクプロパティ]ウィンドウの[link_1]-[JointType]を展開します。
レールに沿って直進するため、[直進]を選択します。
デフォルトでは[軸]が[+Z]になっていますが、X軸方向に直進したいため、[+X]を選択します。
名前を変更します。
[ジョイントプロパティ]-[Name]に[E1]と入力します。
台座を動かすためのサーボコントローラを作成します。
[Controller]-[新規サーボコントローラ]を選択します。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]を展開すると、サーボコントローラが追加されたことが分かります。
最小リミットを定義します。
[リンクプロパティ]ウィンドウの[最小リミット]に[0]と入力します。
最大リミットを定義します。
[ツール]-[測定]を選択します。
台車の端を選択し、ドラッグしてリニアトラックの終点を選択します。
[出力]ウィンドウを確認すると、ワールド距離が1580mmであることがわかります。
[測定]ウィンドウの[閉じる]を選択するか、[escキー]を使用して[測定]ウィンドウを閉じます。
[リンクプロパティ]ウィンドウの[ジョイントプロパティ]-[最大リミット]に[1580]と入力します。
E1の移動距離を設定したため、+X軸方向に1580mmまで移動できます。
[最大速度]に[200]と入力します。
[最大加速]と[最大減速]を[最大速度]の4倍、つまり両方とも「800」に設定します。
[最大加速]と[最大減速]に[800]と入力します。
台車の動きを確認します。
[マニピュレーション]-[インタラクティブ]を選択します。
台車を選択し、ドラッグして動かします。
台車がリニアトラックの両端の制限を超えると、[リンクプロパティ]ウィンドウの[E1]が赤で表示されます。
モーターのジオメトリを台車に追加します。
シミュレーションをリセットします。
コントロールキーを押しながら、モータのジオメトリを全て選択します。
[コンポーネントグラフ]ウィンドウの[ノードフィーチャツリー]のハイライト表示されたサブフィーチャを、
シフトキーを押しながら、[Link_1]にドラッグし、[Link_1]のジオメトリに追加します。
[Link_1]を選択します。
再度台車を選択してドラッグすると、スライドにモーターを追加出来たことがわかります。
シミュレーションをリセットします。
台車にジョイントを設定し、台車を動かす方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

オリジナルのリニアトラックを作ってみよう(2/2)

オリジナルのリニアトラックを作成し、ロボットプログラムを使用して、ロボットをリニアトラックに沿って動かす方法
https://youtu.be/Ch6R0pC-4n4
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_168_p2.zip

オリジナルのリニアトラックを作る方法を説明します。
パート1では、リニアトラックのCADをインポートし、台車を動かす方法を説明しました。
パート2では、リニアトラックにマテリアルを追加し、ロボットをリニアトラックに沿って動かす方法を説明します。
パート1で使用したファイル、もしくは、[Modeling a Robot Positioner_Part1_after.vcmx]をダウンロードし、開きます。
[モデリング]タブを開きます。
ジオメトリにマテリアルを追加します。
台車を選択します。
[ジオメトリ]-[ツール]-[マテリアル]-[割り当て]を選択します。
[モード]は[割り当て]、[次のものにマテリアルを設定]は[設定]を選択します。
[ライブラリ]タブを開きます。
[マテリアルを割り当て]ウィンドウの[マテリアル]に[steel]と入力し、検索します。
[steel_satin]を選択します。
台車のプレート、リニアガイド、ギアラックを選択すると、マテリアルが割り当てられます。
[マテリアルを割り当て]ウィンドウの[マテリアル]に[black]と入力し、検索します。
[black_matte]を選択します。
モーターを選択すると、マテリアルが割り当てられたことがわかります。
[マテリアルを割り当て]ウィンドウの[マテリアル]の検索をクリアにし、[閉じる]を選択します。
その他のジオメトリにマテリアルを追加します。
[コンポーネントグラフ]ウィンドウの[small_track]を選択します。
[コンポーネントプロパティ]ウィンドウの[マテリアル]-[dark_grey]を選択します。
特定のマテリアルが割り当てられていないジオメトリは、全てdark_greyに設定されます。
3Dワールド上を選択します。
コンポーネントの選択が解除され、リニアトラックにマテリアルが割り当てられたことが分かります。
コンポーネントをインターフェースに接続します。
コンポーネントを選択します。
[コンポーネント グラフ]ウィンドウの[small_track]を選択し、コンポーネント全体を選択します。
ロボットの外部軸として動かすため、ポジショナを設定します。
[追加]-[ウィザード]-[ポジショナ]を選択します。
[ポジショナ]ウィンドウの[ポジショナータイプ]に[Workpiece Positioner]が選択されています。
Workpiece Positionerは、ターンテーブルのように、加工対象物を適切な位置に固定・移動するときに使用します。
Robot Positionerは、リニアトラックのように、ロボット自体を適切な位置に配置・移動するときに使用します。
今回は、リニアトラックにロボットを接続するため、Robot Positionerを選択します。
Link_1にロボットを接続するため、[フランジの接合]-[Link_1]のままにします。
[適用する]を選択します。
[閉じる]を選択します。
[出力]ウィンドウを確認すると、Robot Posirionerが設定されたことがわかります。
フレームが表示されていない場合は、[3Dワールドツールバー]の[フレームタイプ]-[フレーム]を選択します。
[コンポーネントグラフ]ウィンドウの[Link_1]を展開します。
ロボットを取り付けるための[MountInterface]と、ロボットがスナップされる位置を示すフレームが追加されていることがわかります。
フレームは[Link_1]の台車の上部中央に配置されています。
フレームの位置を変更したい場合は、フレームを選択し、[マニピュレーション]-[移動]や[ツール]-[スナップ]で移動します。
今回は、位置に問題がないため、移動は不要です。
ロボットをリニアトラックに沿って動かします。
台車にロボットを配置します。
[ホーム]タブを開きます。
eカタログの[タイプ別モデル]-[Robots]を展開します。
[Mitsubishi Electric]を選択します。
[RV-7FL]をドラッグし、3Dワールドに追加します。
[マニピュレーション]-[PNP]が選択されている状態で、ロボットをリニアトラックの台車にスナップします。
フレームの位置にスナップされたことが分かります。
シミュレーションコントロールの歯車を選択します。
状態の保存を選択すると、現在の位置が保存されます。
[プログラム]タブを開きます。
[マニピュレーション]-[ジョグ]を選択します。
各軸補間ステートメントを使用してロボットを移動します。
[ジョグ]ウィンドウの[ジョイント]-[J1]を左にスライドし、ロボットを動かします。
6つのロボットのジョイントに加えて、リニアトラックが外部ジョイントとして追加されています。
[E1]を右にスライドすると、ロボットが移動します。
[サブプログラム]-[Main]に[各軸補間ステートメント]を追加します。
[各軸補間ステートメント]は、ロボットの位置を記録し、ジョイントの値を補間して動かすことができます。
緑色の四角をドラッグし、ロボットを平行移動します。
[E1]を左にスライドし、ロボットを移動します。
[サブプログラム]-[Main]に[各軸補間ステートメント]を追加します。
シミュレーションをリセットします。
シミュレーションを実行します。
ロボットがリニアトラックに沿って移動していることがわかります。
リニアトラックにマテリアルを追加し、ロボットをリニアトラックに沿って動かす方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

カーブするコンベアを作ってみよう

オリジナルのカーブするコンベアを作る方法
https://youtu.be/JRA2oBTVlII
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_038.zip

パラメトリックコンベアをモデル化する方法を説明します。
[モデリング]タブをクリックします。
[コンポーネント]グループの[新規]をクリックし新しいコンポーネントを作成します。
[コンポーネントプロパティ]パネルから[名前]を「Parametric Coneyor」に設定します。
[コンポーネント]グループの[保存]をクリックします。
[コンポーネントを保存]パネルから[基本情報]の[タイプ]を「Conveyors」に設定します。
[保存]をクリックし「My Models」フォルダに保存します。
コンベアの足を作成します。
[プリミティブジオメトリ]の[ボックス]フィーチャを使用しコンベアの足を表現します。
[コンポーネントプロパティ]を使用しボックスフィーチャの高さを設定することでコンベアの足の長さを制御します。
[プロパティ]グループの[プロパティ]から[ベーシック]の[実数]を選択します。
[プロパティ]パネルから[名前]を「ConveyorHeight」、[量]を「Distance」、[値]を「700」に設定します。
[ジオメトリ]グループの[フィーチャ]から[プリミティブジオメトリ]の[ボックス]を選択します。
[フィーチャプロパティ]パネルから[長さ]と[幅]を「80」、[高さ]を「ConveyorHeight」に設定します。
コンベアの足が1本作成されたことを確認します。
コンベアの足を複製します。
クローンフィーチャを使用しコンベアの足を複製します。
コンポーネントプロパティを使用し足を配置する間隔を設定することでコンベアの幅を制御します。
[プロパティ]グループの[プロパティ]から[ベーシック]の[実数]を選択します。
[プロパティ]パネルから[名前]を「ConveyorWidth」、[量]を「Distance」、[値]を「400」に設定します。
[ジオメトリ]グループの[フィーチャ]から[クローン]の[直線クローン]を選択します。
[フィーチャプロパティ]パネルから[カウント]を「2」、[ステップ]を「ConveyorWidth」に設定します。
Y軸方向に複製するため[方向]を「Vector(0,1,0)」に設定します。
方向はXYZの順になっておりクローンで増減させたい方向に1を立てます。
フィーチャツリーから「ブロック」を「LinearClone」の子階層になるようにドラッグアンドドロップで移動します。
コンベアの足がY軸方向に「ConveyorWidth」で設定した間隔をあけ複製されたことを確認します。
コンベアの足を原点から移動します。
原点を中心とした角度でジオメトリを複製するため円の半径を設定します。
コンポーネントプロパティを使用しトランスフォームフィーチャを制御することでコンベアの足をY軸方向に移動します。
[プロパティ]グループの[プロパティ]から[ベーシック]の[実数]を選択します。
[プロパティ]パネルから[名前]を「ConveyorRadius」、[量]を「Distance」、[値]を「1000」に設定します。
[ジオメトリ]グループの[フィーチャ]から[トランスフォーム]を選択します。
[フィーチャプロパティ]パネルから[数式]を「Ty(ConveyorRadius)」に設定します。
フィーチャツリーから「LinearClone」を「トランスフォーム」の子階層になるようにドラッグアンドドロップで移動します。
Y軸方向にコンベアの足が移動したことが確認できます。
トランスフォームを選択し[マニピュレーション]グループの[移動]をクリックします。
Z軸を中心に「トランスフォーム」を回転させます。
トランスフォームを回転させることでコンベアの足が原点を中心に回転することが確認できます。
[移動モード]設定が[ヒエラルキー]の場合「トランスフォーム」を回転させることで「ブロック」が移動します。
「トランスフォーム」の[フィーチャプロパティ]パネルから[Rz]をクリックしZ軸を中心とした回転を「0」にリセットします。
原点を中心とした角度に沿ってコンベアの足を複製します。
[コンポーネントプロパティ]を使用しコンベアの角度を制御します。
[プロパティ]グループの[プロパティ]から[ベーシック]の[実数]を選択します。
[プロパティ]パネルから[名前]を「ConveyorAngle」、[量]を「Angle」、[値]を「45」に設定します。
[ジオメトリ]グループの[フィーチャ]から[クローン]の[角度クローン]を選択します。
[フィーチャプロパティ]パネルから[カウント]を「4」、[ステップ]を「ConveyorAngle/3」に設定します。
フィーチャツリーから「トランスフォーム」を「AngularClone」の子階層になるようにドラッグアンドドロップで移動します。
45度の角度に沿ってコンベアの足が複製されたことが確認できます。
コンベアのロールバーを作成します。
プリミティブジオメトリの円柱フィーチャを使用しロールバーを表現します。
コンポーネントプロパティを使用し円柱の半径を設定することでロールバーの幅を制御します。
[プロパティ]グループの[プロパティ]から[ベーシック]の[実数]を選択します。
[プロパティ]パネルから[名前]を「RollRadius」、[量]を「Distance」、[値]を「20」に設定します。
[ジオメトリ]グループの[フィーチャ]から[プリミティブジオメトリ]の[円柱]を選択します。
[フィーチャプロパティ]パネルから[半径]を「RollRadius」、[高さ]を「ConveyorWidth-80」に設定します。
ワールド座標で[Rx]を「-90」に設定しコンベアのロールバーを回転させます。
ロールバーを移動し2本の足の間に配置します。
[ジオメトリ]グループの[フィーチャ]から[トランスフォーム]を選択します。
[フィーチャプロパティ]パネルの[数式]を「Ty(ConveyorRadius+80).Tx(50).Tz(ConveyorHeight-RollRadius)」に設定します。
数式は右から左へ適用されます。
「トランスフォーム_1」の場合最初にZ軸方向次にX軸方向に平行移動し最後にy軸を中心に回転します。
フィーチャツリーから円柱を「トランスフォーム_1」の子階層になるようにドラッグアンドドロップで移動します。
ロールバーが2本の足の間に移動したことが確認できます。
円弧に沿ってロールバーを複製します。
コンベアの角度と半径から円弧の長さを計算します。
コンポーネントプロパティを使用し各ロールバー間の距離を計算および制御します。
[プロパティ]グループの[プロパティ]から[ベーシック]の[実数]を選択します。
[プロパティ]パネルから[名前]を「RollDistance」、[量]を「Distance」、[値]を「50」に設定します。
[ジオメトリ]グループの[フィーチャ]にある[クローン]から[角度クローン]を選択します。
単位を角度からラジアンへ変換します。
角度に0.0174をかけラジアンに変換します。
[フィーチャプロパティ]パネルから[カウント]を「(ConveyorAngle*ConveyorRadius*0.0174)/RollDistance+2」に設定します。
ステップを「RollDistance/(ConveyorRadius*0.0174)」に設定します。
フィーチャツリーから「トランスフォーム_1」を「AngularClone_1」の子体層になるようにドラッグアンドドロップで移動します。
円弧に沿ってロールバーが複製されたことが確認できます。
コンベアのサイドレールを作成します。
ボックスフィーチャまたはパイソンフィーチャを使用しサイドレールを表現します。
フィーチャツリーを有効または無効にするためボックスフィーチャとパイソンフィーチャに加えスイッチフィーチャを使用する方法を説明します。
[ジオメトリ]グループの[フィーチャ]から[その他]から[スイッチ]を選択します。
[ジオメトリ]グループの[フィーチャ]から[プリミティブジオメトリ]の[ボックス]を選択します。
[フィーチャプロパティ]パネルから[長さ]、[幅]および[高さ]を「80」に設定します。
フィーチャツリーから「ブロック_1」を「スイッチ」の子階層になるようにドラッグアンドドロップで移動します。
「スイッチ」をクリックし[選択]が「0」であることを確認します。
[選択]が「0」の場合、子階層の0番目のフィーチャを表示するため1番目のフィーチャである「ブロック_1」は非表示となります。
PythonフィーチャはPython APIを使用してスクリプトを作成することによりカスタムフィーチャを作成できます。
スクリプトはフィーチャツリーの他のフィーチャと同様最下位の階層から最上位の階層に到達するまで評価されます。
Pythonフィーチャをトランスフォームフィーチャとして使用し子階層のフィーチャを変換することができます。
トランスフォームフィーチャとして使用した場合Pythonフィーチャによってジオメトリを作成し形状を操作することができます。
[ジオメトリ]グループの[フィーチャ]（正しくは[動作設定]グループの[ビヘイビア]）から[その他]のPythonを選択します。
フィーチャツリーから「パイソンフィーチャ」を「スイッチ」の子階層になるようにドラッグアンドドロップで移動します。
「スイッチ」の子階層を「パイソンフィーチャ」、「ブロック_1」の順番に並べます。
[フィーチャプロパティ]パネルから[エディタで開く]をクリックしスクリプトエディタを表示します。
スクリプトエディタに記述を追加し3Dワールドに四角形を作成します。
2行目に「import vcVector」と記述します。
「OnEvaluate」関数はフィーチャツリーを再構築することで再生されます。
「OnEvaluate」関数とfor文の間に「target.clear()」と記述します。
ジオメトリコンテナである「target」からすべてのジオメトリを削除することができます。
ジオメトリコンテナにジオメトリセットを作成します。
「c_set = target.createGeometrySet(VC_COMPACTLINESET)」と記述します。
四角形の頂点を設定します。
「line = [vcVector.new(0,0,0),vcVector.new(0,0,80),vcVector.new(0,80,80),\」、「vcVector.new(0,80,0),vcVector.new(0,0,0)]」と記述します。
「c_set.addLine(line)」と記述することでジオメトリセットに新しいラインを作成することができます。
Pythonスクリプトをコンパイルします。
「スイッチ」を選択し[フィーチャプロパティ]パネルから[選択]を「1」に設定します。
スイッチは子階層の1番目のフィーチャである「パイソンフィーチャ」を選択しており平面の四角形を表示しています。
「ブロック_1」をサイドレールとして使用するため[選択]を「2」に変更します。
サイドレールを複製し2つのサイドレールのセットを作成します。
[ジオメトリ]グループの[フィーチャ]から[クローン]の[直線クローン]を選択します。
[フィーチャプロパティ]パネルから[カウント]を「2」、[ステップ]を「ConveyorWidth」、[方向]を「Vector(0,1,0)」に設定します。
フィーチャツリーから「スイッチ」を「LinearClone_1」の子階層になるようにドラッグ&ドロップで移動します。
サイドレールを複製しました。
サイドレールを原点から移動させコンベアの開始位置の両サイドに配置します。
次の工程にてサイドレールを回転させ曲面を形成するため移動ではなくトランスフォームフィーチャを使用しサイドレールを移動します。
[ジオメトリ]グループの[フィーチャ]から「トランスフォーム」を選択します。
[フィーチャプロパティ]パネルから数式を「Ty(ConveyorRadius).Tz(ConveyorHeight-80)」に設定します。
フィーチャツリーから「LinearClone_1」を「トランスフォーム_2」の子階層になるようにドラッグアンドドロップで移動します。
サイドレールがコンベアの開始位置の両サイドに配置されたことを確認します。
サイドレールを原点を中心に回転させ曲面を形成します。
サイドレールのジオメトリはスイープのプロファイルとなります。
[ジオメトリ]グループの[フィーチャ]から生成の回転を選択します。
[フィーチャプロパティ]パネルから[回転角度]を「ConveyorAngle」に設定します。
フィーチャツリーから「トランスフォーム_2」を「回転」の子階層になるようにドラッグアンドドロップで移動します。
サイドレールが作成されたことを確認します。
ロールコンベアの作成についての説明は以上となります。
パラメトリックコンベアはロールバーまたはベルト上をコンポーネントが移動できます。
ベルトコンベアのベルト部分を作成します。
プロパティからベーシックの文字列をパラメトリックコンベアに追加し名前を「Conveyor Type」に設定します。
制約に「Belt Conveyor」「Roll Conveyor」と入力します。
[コンポーネントプロパティ]パネルに選択肢を表示することができます。
値を「Roll Conveyor」に設定します。
スイッチフィーチャを追加します。
「トランスフォーム_1」をコピーし「スイッチ_1」に貼り付けます。
「トランスフォーム_1」をコピーすることで子階層も一緒にコピーすることができます。
回転フィーチャを追加し[回転角度]を「ConveyorAngle」に設定します。
フィーチャツリーから「回転_1」を「スイッチ_1」の子階層になるようにドラッグアンドドロップで移動します。
「トランスフォーム_1」を「回転_1」の子階層になるようにドラッグアンドドロップで移動します。
「AngularClone_1」を「スイッチ_1」の子階層になるようにドラッグアンドドロップで移動します。
「AngularClone_1」「回転_1」の順番に並べ替えます。
「スイッチ_1」を選択します。
[選択]に「ConveyorType=="RollConveyor"?1:ConveyorType=="BeltConveyor"?2:0」と入力します。
条件演算子を使用し[ConveyorType]の値を評価しています。
[ConveyorType]の「RollConveyor」を選択した場合「スイッチ_1」はロールバーを生成するフィーチャツリーを選択しロールバーが表示されます。
[ConveyorType]を「BeltConveyor」に変更します。
「スイッチ_1」はベルトを生成するフィーチャツリーを選択しベルトコンベアが表示されたことが確認できます。
フレームフィーチャをコンベアに追加し移動するコンポーネントのウェイポイントとして使用することができます。
フレームフィーチャを回転および移動しコンベアの開始位置から終了位置までの曲線パスを形成します。
パスに開始位置を設定するためフレームフィーチャを追加します。
3Dワールドツールバーのフレームタイプをクリックしフレームにチェックを入れることでフレームフィーチャを表示できます。
[ジオメトリ]グループの[フィーチャ]からトランスフォームを選択します。
[フィーチャプロパティ]パネルから[数式]を「Tz(ConveyorHeight).Ty(ConveyorRadius+ConveyorWidth+80/2.0).Tx(80)」に設定します。
[ジオメトリ]グループの[フィーチャ]から[その他]の「フレーム」を選択します。
[フィーチャプロパティ]パネルから[Rz]を「180」に設定しフレームの+X軸をコンポーネントがコンベアに沿って移動する方向に設定します。
フィーチャツリーからフレームを「トランスフォーム_3」の子階層になるようにドラッグアンドドロップで移動します。
フレームがコンベアの開始位置に移動したことを確認します。
バスに一つ目の中間地点を設定するためフレームフィーチャを追加します。
トランスフォームフィーチャを追加し[数式]を「Tz(ConveyorHeight).Rz(ConveyorAngle/4).Ty(ConveyorRadius+ConveyorAgnel/4).Ty(ConveyorWidth+80)=2.0」に設定します。
フレームフィーチャを追加しZ軸を中心に180度回転させます。
「フレーム_1」を「トランスフォーム_4」の子階層になるようにドラッグアンドドロップで移動します。
パスに2つ目の中間地点を設定するためフレームフィーチャを追加します。
トランスフォームフィーチャを追加し数式を「Tz(ConveyorHeight).Rz(ConveyorAngle*2.0/4.0).Ty(ConveyorRadius+ConveyorWidth+80/2.0)」に設定します。
フレームフィーチャを追加しZ軸を中心に180度回転させます。
「フレーム_2」を「トランスフォーム_5」の子階層になるようにドラッグアンドドロップで移動します。
バスに3つ目の中間地点を設定するためフレームフィーチャを追加します。
トランスフォームフィーチャを追加し数式を「Tz(ConveyorHeight).Rz(ConveyorAngle*3.0/4.0).Ty(ConveyorRadius+ConveyorWidth+80/2.0)」に設定します。
フレームフィーチャを追加しZ軸を中心に180度回転させます。
「フレーム_3」を「トランスフォーム_6」の子階層になるようにドラッグアンドドロップで移動します。
パスに終了位置を設定するためフレームフィーチャを追加します。
トランスフォームフィーチャを追加し数式を「Tz(ConveyorHeight).Rz(ConveyorAngle).Ty(ConveyorRadius+ConveyorWidth+80/2.0)」に設定します。
フレームフィーチャを追加しZ軸を中心に180度回転させます。
「フレーム_4」を「トランスフォーム_7」の子階層になるようにドラッグアンドドロップで移動します。
コンベアウィザードを使用することでコンベアにパスとインターフェースを素早く設定することができます。
パスとインターフェースを設定することによりコンベアはシミュレーション再生中他の装置との間でコンポーネントを移動させることができます。
[追加]グループの[ウィザード]から[コンベア]を選択します。
[コンベア]パネルから[フレームモード]を「Choose Manually」に設定し一覧表示されたすべてのフレームフィーチャにチェックを入れます。
[パスの補間]を「Cubic」に設定し[コンベヤーの動作を作成する]をクリックします。
[閉じる]をクリックします。
パスを選択し[プロパティ]パネルのパスを変更することでコンポーネントを移動させる順番を変更できます。
コンベアの動作を確認します。
[コンポーネント]グループの[保存]をクリックしコンポーネントを保存します。
[ホーム]タブをクリックします。
[コンポーネントプロパティ]パネルからConveyorWidthを「500」に設定します。
eカタログのタイプ別モデルからFeedersをクリックします。
Shape Feederを3Dワールドに追加しコンベアの開始位置に接続します。
eカタログのタイプ別モデルからConveyorsをクリックします。
Visual ComponentsからConveyorを3Dワールドに追加しコンベアの終了位置に接続します。
eカタログのタイプ別モデルの下にあるConveyor Utilitiesをクリックします。
Conveyor Sensorを3Dワールドに追加しパラメトリックコンベヤーのパスに接続します。
Conveyor Sensorは外部センサーとしてパスに接続されます。
シミュレーションを再生します。
フィーダーから生成された箱がパラメトリックコンベアを流れ次のコンベアに流れることを確認します。
シミュレーションをリセットします。
[ファイル]タブの[名前を付けて保存]をクリックしレイアウトを保存します。
コンポーネントジオメトリにマテリアルを割り当てます。
ジオメトリフィーチャリンクまたはコンポーネント全体にマテリアルを割り当てることができます。
"3Dワールドでパラメトリックコンベアを選択し[コンポーネントプロパティ]パネルからマテリアルを「steel_crosspattern」に設定します"。
コンポーネントに独自のマテリアルを割り当てていないためコンポーネント内のすべてのフィーチャに影響を与えています。
[モデリング]タブをクリックします。
[ジオメトリ]グループの[ツール]から[マテリアル]の[割り当て]を選択します。
[マテリアルを割り当て]パネルのマテリアルから「chrome」を検索し選択します。
3Dワールドでロールバーを選択します。
すべてのロールバーにChromeが割り当てられました。
パラメトリックコンベヤーの足に「aluminium」を割り当てます。
パラメトリックコンベヤーの足とサイドレールのジオメトリが重なっているため足の長さを変更します。
フィーチャツリーからブロックを選択し[マテリアルを割り当て]パネルの下側にあるフィーチャプロパティをクリックします。
高さを「ConveyorHeigh-80」に変更します。
[マテリアルを割り当て]パネルに戻ります。
[モード]の「選択」をクリックしオブジェクトのマテリアルを調査します。
3DワールドでConveyorのベルトをクリックします。
ベルトのマテリアルが「rubber」であることを確認します。
3Dワールドのフィーチャではなくマテリアルを選択しています。
パラメトリックコンベアーのベルトを生成する「回転_1」を選択し、[フィーチャプロパティ]パネルからマテリアルを「rubber」に設定します。
[Conveyor Type]で「Belt Conveyor」を選択しベルトに「rubber」が割り当てられていることを確認します。
コンポーネントを保存します。
パラメトリックコンベアをモデル化する方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

カム機構を作ってみよう(1/2)

オリジナルのカム機構を持つ装置を作成する方法
（3DCADファイルをインポート、可動部を分割）
https://youtu.be/sMLMZwlBCM0
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_112_p1.zip

カム機構を作成する方法について説明します。
カム機構とは、運動の方向を変化させる機構です。
設定が完了すると、回転運動を、直線運動に変換するピストンが完成します。
本動画では、ピストンをインポートし、3つの可動部に分割します。
CADファイルをインポートします。
[ホーム]タブ、または[モデリング]タブをクリックします。
[インポート]グループの[ジオメトリ]をクリックすることで、CADファイルをインポートできます。
[Cam.step]を選択し、[開く]をクリックします。
[モデルをインポート]ウィンドウでは、インポート時のプロパティを設定できます。
[構造]は、モデルを分割する方法を設定できます。
[フィーチャ]は、分割せず、[ノード]は、ジオメトリをすべて別のノードに分割します。
[コンポーネント]は、ジオメトリをすべて別のコンポーネントに分割します。
単一のモデルをインポートする場合、[フィーチャ]か[ノード]を選択します。
レイアウトをインポートする場合、[コンポーネント]を選択します。
[Cam.step]は、単一のモデルとしてインポートするため、[フィーチャ]を選択します。
3Dワールドに表示されるモデルは、多数の三角形で構成されており、[テッセレーションの品質]は、三角形の個数を設定できます。
モデルのデータ量に応じて品質を変更します。
低品質にすることで、モデルのデータ量を削減できます。
今回のモデルは、データ量が少ないため、[中位品質]に設定します。
[含める]では、インポート時のジオメトリに含む要素を設定できます。
今回は、[マークアップ]と[マテリアル]と[テクスチャー]を選択します。
[マテリアル作成ルール]では、マテリアルライブラリを作成するためのルールを設定できます。
今回は、[常にライブラリから最も近似のものを使用します]を選択します。
[フィーチャツリー]は、フィーチャツリーの作成方法を、設定できます。
[完全]は、トランスフォームフィーチャを使用し、CADファイルと階層構造を完全に一致させます。
[最適化]は、すべてのジオメトリを同じ階層にし、[最小化]は、ジオメトリを1つにまとめることができます。
ピストンに可動部を設定しやすくするため、フィーチャツリーをシンプルな状態にします。
[最適化]を選択します。
[ジオメトリを整理]では、ジオメトリセットを作成するためのルールを設定できます。
ジオメトリセットは、フィーチャツリーの各ジオメトリの中に含まれるジオメトリのまとまりです。
メッシュを構成する三角ポリゴンの3点の合計が10000を超えると、新しいジオメトリセットが作成されます。
[面による]は、面ごとに、[マテリアルによる]は、マテリアル事にジオメトリセットを作成できます。
[折りたたみ]は、ジオメトリセットを1つにまとめ、[数学的データ]は、曲線のジオメトリセットを作成できます。
今回は、[マテリアルによる]を選択します。
[上軸]は、ジオメトリの上面と底面を整列させる軸を設定できます。
[上軸]で[+Z]を選択し、[インポート]をクリックします。
3Dワールドに、ピストンをインポートできたことがわかります。
ピストンの可動部を設定するため、[モデリング]タブを開きます。
回転運動する可動部を設定します。
3Dワールドで、ピストンの青い部分を選択します。
右クリックして、メニューを開きます。
[抽出]から[抽出リンク]を選択することで、選択したジオメトリを新しいノードに抽出できます。
[コンポーネントグラフ]ウィンドウに、「Link_1」が追加されたことがわかります。
ノードに回転運動させる場合、回転軸は、ノードの原点です。
ノードの原点を移動させ、Link_1に抽出したジオメトリの中心を、回転軸に設定します。
[移動モード]が、[ヒエラルキー]の場合、選択したものとその子階層にあるものをすべて移動させます。
[移動モード]を、[選択済み]に変更し、選択したもののみを移動させます。
「Link_1」の原点のみを移動させます。
「Link_1」を選択します。
[ツール]グループの[スナップ]を選択し、3Dワールドで任意の位置をクリックすることで、選択したものを移動させられます。
円形ジオメトリの中心をクリックします。
[移動モード]を[ヒエラルキー]に戻します。
同様に、緑のジオメトリと、赤のジオメトリを、それぞれ別のノードに抽出します。
[コンポーネントグラフ]ウィンドウに、Link_2と「Link_3」が追加されたことがわかります。
「Link_2」の原点を移動させます。
[移動モード]を、[選択済み]に変更します。
「Link_2」を選択し、[ツール]グループの[スナップ]を選択します。
3Dワールドで、モデルの青い部分と緑の部分をつないでいる黒い円柱の中心をクリックします。
「Link_3」の原点を移動させます。
「Link_3」を選択し、[ツール]グループの[スナップ]を選択します。
3Dワールドで、モデルの緑の部分と赤い部分をつないでいる黒い円柱の中心をクリックします。
[移動モード]を[ヒエラルキー]に戻します。
ノードに階層構造を設定し、親ノードの動作に追従できるようにします。
[コンポーネントグラフ]ウィンドウで、「Link_2」を選択し、シフトキーを押した状態で、Link_1にドラッグ＆ドロップします。
シフトキーを押し忘れてジオメトリが移動した場合、シフトキーを押さずに、元のノードにドラッグ＆ドロップすることで、ジオメトリの位置が戻ります。
「Link_3」を選択し、シフトキーを押した状態で、Link_2にドラッグ＆ドロップします。
「Link_3」は、「Link_2」の子階層にあり、「Link_2」は、「Link_1」の子階層にあることがわかります。
ピストンをインポートし、3つの可動部に分割する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

カム機構を作ってみよう(2/2)

オリジナルのカム機構を持つ装置を作成する方法
（機構付け、可動部の運動量を三角関数で計算）
https://youtu.be/y7nkiPgfC_g
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_112_p2.zip

カム機構を作成する方法について説明します。
本動画は、ピストンの可動部を分割する方法の続きから設定します。
ピストンの可動部が分割されたファイル[Cam_after.vcmx]が必要です。
可動部に動作の詳細を設定します。
「Link_1」を選択します。
[リンクプロパティ]ウィンドウで、[JointType]を設定することで、動作の種類を定義できます。
[固定]は、動作を設定せず、ノードを定義した位置に固定できます。
[回転]は、定義した軸を中心に回転運動、[直進]は、軸に沿って直線運動できます。
[回転フォロワー]は、別のノードの運動量と連動した回転運動ができます。
[直進フォロワー]も[回転フォロワー]と同様に、別のノードと連動した直線運動です。
[カスタム]は、定義した軸を基準に、回転または直線運動できます。
今回は、[回転]を選択します。
原点の軸方向を設定します。
[軸]で-Zを選択します。
[軸]で選択する方向は、3Dワールドではなく、ノード自体の方向です。
[リンクプロパティ]ウィンドウの、[座標]の右側にある[オブジェクト]を選択することで、選択しているノードの方向を確認できます。
[Controller]は、ノードの動作を制御するコントローラーを定義できます。
[Controller]をクリックし、「新規サーボコントローラ」を選択します。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]を展開すると、サーボコントローラが追加されていることがわかります。
Geminiのサーボコントローラは、一般的なサーボコントローラとは異なり、可動部を制御する仮想のコントローラーを意味します。
[リンクプロパティ]ウィンドウの[初期値]は、ノードの初期位置、[J1]は、ノードの現在位置を表示しています。
現在、[初期値]と[J1]は0です。
[最小リミット]と[最大リミット]は、ノードが動作できる範囲の最小値と最大値を定義できます。
[最小リミット]と[最大リミット]を空白にすることで、動作できる範囲を制限しないこともできます。
今回は、動作できる範囲を制限しないため、空白にします。
動作を確認します。
[マニピュレーション]グループの[インタラクティブ]を選択することで、可動部の動作を確認できます。
3Dワールドで、「Link_1」をドラッグします。
「Link_1」が、Z軸を中心に回転し、Link_2と「Link_3」が追従していることがわかります。
Link_2と「Link_3」が、「Link_1」の運動量と連動して動作するように設定します。
シミュレーションのリセットボタンをクリックすることで、可動部を初期位置に戻すことができます。
「Link_2」を選択します。
[リンクプロパティ]ウィンドウの[JointType]で、[回転フォロワー]を選択します。
「Link_1」が回転した時、「Link_3」の原点が上下に動作しないようにします。
「Link_2」の回転する方向を、「Link_1」と反対にすることで、「Link_1」の回転を相殺します。
[軸]で+Zを選択します。
[ドライバー]は、動作を連動させるために参照する別のノードの運動量です。
[ドライバー]で、[サーボコントローラ]のJ1を選択します。
[数式値]のVALUEに、「Link_1」と同じ運動量が入力されます。
「Link_3」を選択します。
[リンクプロパティ]ウィンドウの[JointType]で、[回転フォロワー]を選択します。
「Link_1」が回転した時、「Link_3」を水平な状態にするため、[軸]で-Zを選択します。
[ドライバー]で、[サーボコントローラ]のJ1を選択します。
動作を確認します。
3Dワールドで、「Link_1」をドラッグします。
「Link_3」は、「Link_1」と同じ角度、同じ方向に回転し、「Link_2」は同じ角度ですが、反対方向に回転することがわかります。
Link_2と「Link_3」の運動量を、「Link_1」の運動量をもとに計算し、回転運動を直線運動に変換します。
「Link_3」の運動量を計算する数式を入力します。
「Link_1」、「Link_2」、「Link_3」の原点をA、B、Cとし、BからACにおろした垂線と、ACの交わる点をDとします。
ABDと、BCDの2つの三角形から、「Link_3」の運動量に当たるCの角度を求めます。
ABとBCは「Link_1」が回転しても長さは変化しません。
ABは120mm、BCは600mmです。
逆三角関数を使用し、Cの角度はarcsin(sinC)という計算で、求めることができます。
次に、sinCを求める必要があります。
sinCは、BD/BCで、求めることができます。
BDを三角形ABDから求めます。
BDは、AB*sinAで求めることができます。
Aは、「Link_1」の回転角度、ABは120であるため、数式にすると、BD=120*sin(VALUE)です。
sinCの数式に当てはめると、sinC=120*sin(VALUE)/600です。
Cの角度を求める数式は、C=arcsin(120*sin(VALUE)/600)となります。
Geminiで使用する三角関数は、ヘルプファイルで確認できます。
[ヘルプ]タブを開き、[ヘルプ]クリックします。
[目次]の[数式]を展開し、[関数]をクリックします。
Geminiでは、三角関数はsin、cos、tan、ですが、逆三角関数はasin、acos、atanです。
三角関数の角度計算には、ラジアンが使用されます。
度数を使用する必要があるため、関数名の語尾に「d」を付加します。
[モデリング]タブを開きます。
「Link_3」を選択します。
[リンクプロパティ]ウィンドウの[数式値]に、asind(120*sind(VALUE)/600)と入力します。
「Link_2」の運動量を計算する数式を入力します。
「Link_2」の運動量は、「Link_1」と「Link_3」の運動量の合計です。
「Link_2」を選択します。
[リンクプロパティ]ウィンドウの[数式値]に、VALUE+asind(120*sind(VALUE)/600)と入力します。
動作を確認します。
3Dワールドで、「Link_1」をドラッグします。
「Link_1」の回転運動が、Link_3では直線運動に変換されていることがわかります。
リセットボタンをクリックします。
カム機構を作成する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

グラフのデータの色を変更しよう

Pythonスクリプトを使用して、統計情報のダッシュボードに表示されるグラフのデータの色を変更する方法。（Dashboard、Tabs、Charts、Series、Colors、RGBの指定）
https://youtu.be/s2ELp5kkmuE
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_188.zip

統計情報のダッシュボードで表示できるグラフのデータの色を変更する方法について説明します。
統計情報のダッシュボードが設定されているレイアウトを、eカタログから配置します。
eカタログ、[タイプ別モデル]-[Layout Templates]から、「Statistics Layout」を、ダブルクリック、またはドラッグ＆ドロップで、配置します。
[統計情報]グループから[統計情報]を選択することで、統計情報のダッシュボードを表示できます。
統計情報のダッシュボードにグラフを作成する方法は、動画「統計情報を表示してみよう」を参照してください。
「Statistics Layout」のダッシュボードには、4つのタブがあり、タブごとにグラフが1つ以上設定されています。
グラフのデータは色で分けられていますが、色の割り振りは自動です。
データの色を、任意の色に変更します。
[Machine & Process Node]タブにある[Parametric Lathe - State]グラフの[Idle]の色を変更します。
現在、[Idle]の色は緑です。
[モデリング]タブを開きます。
新しいコンポーネントを作成するため、[コンポーネント]グループの[新規]を選択します。
3Dワールドで選択できるようにするため、[ジオメトリ]グループの[フィーチャ]から[ブロック]を追加します。
PythonScriptに、データの色を変更するプログラムを記述します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
PythonScriptエディタが自動的に開きます。
デフォルトで記述されているソースコードを、1行目以外削除します。
データを取得するためには、Geminiのアプリケーション、ダッシュボード、タブ、グラフ、データの順に取得する必要があります。
app = getApplication()と記述することで、Geminiのアプリケーションを取得できます。
appは変数名です。
任意の変数名に変更することもできます。
アプリケーションの詳細については、[ヘルプ]タブ-[Python API]を選択し、vcApplicationで確認してください。
dash = app.Dashboardと記述することで、ダッシュボードを取得できます。
ダッシュボードを呼び出すときは、dashと記述します。
ダッシュボードの詳細については、ヘルプのvcStatisticsDashboardで確認してください。
tab = dash.Tabsと記述することで、ダッシュボードに設定されているタブのリストを取得できます。
1つのタブを指定する場合、リスト内での番号を追記します。
ダッシュボードの左から順に、0、1、2、3と、番号が振られています。
今回は、[Machine & Process Node]タブを指定するため、[2]と追記します。
タブのリストの詳細については、ヘルプのvcStatisticsTabで確認してください。
graph = tab.Chartsと記述することで、タブに設定されているグラフのリストを取得できます。
1つのグラフを指定するため、リスト内での番号を追記します。
[Statistics]ウィンドウの[+]アイコンを選択することで表示される[レイアウトを選択]画面で確認できます。
[Machine & Process Node]タブのレイアウトは、[2列1行標準ダッシュボード]です。
リストの番号は、0から始まるため、[Parametric Lathe - State]グラフは、0となります。
graph = tab.Chartsに[0]と追記します。
グラフのリストの詳細については、ヘルプのvcStatisticsChartで確認してください。
data = graph.Seriesと記述することで、グラフに設定されているデータのリストを取得できます。
1つのデータを指定するため、番号を追記します。
データは上から順に、番号が振られています。
今回は、[Idle]を指定するため、[1]と追記します。
データのリストの詳細については、ヘルプのvcStatisticsSeriesで確認してください。
[例: データ系列のソースの定義]には、グラフの色を変更するPythonスクリプトの例を記載しています。
ヘルプの例では、統計情報に追加するデータのコンポーネント、プロパティ、データの色を指定しています。
動画では、既に設定されている統計情報のデータに対して、色を指定する方法を説明しています。
取得したデータを確認するため、print data.Nameと記述します。
PythonScriptエディタ左上のコンパイルを選択します。
[出力]ウィンドウに、取得したデータの名前が表示されます。
[Idle]を取得できたことがわかります。
PythonScriptエディタに戻り、print文を削除します。
データの色を定義する項目を取得し、値を変更します。
色を定義する項目に入力する値は、ベクトル形式です。
ベクトルを作成可能にするため、import vcVectorと記述します。
color = vcVector.new()と記述することで、新しいベクトルを作成できます。
ベクトルの3つの成分に、色の情報を入力します。
色の情報は、RGBと呼ばれる数値で表します。
RGBは、Red、Green、Blueの略称です。
一般的に、RGBは、0から255の範囲を持つ数値です。
数値が0の場合、その色の情報を全く含まないことを表し、255の場合、最大限含むことを表します。
Geminiのベクトルで色を表す方法は、一般的なRGBと異なるため、注意が必要です。
0が色の情報を全く含まないことは同様ですが、1の場合、色の成分を最大限含み、256に近づくにつれ、色の成分を含まなくなります。
vcVector.new()のカッコ内に数値を入力し、色を指定します。
0,0,1と入力します。
データの色を定義する項目の値を変更します。
「data=」の次の行に、data.Colors = [color]と記述することで、データの色を変更できます。
PythonScriptをコンパイルします。
[Statistics]ウィンドウを表示します。
[Machine & Process Node]タブにある[Parametric Lathe - State]グラフの[Idle]の色が、緑から青に変化したことがわかります。
一般的なRGBの値を元に色を設定する方法を説明します。
PythonScriptエディタを表示します。
color=vcVector.new()のカッコ内の数値を、256から一般的なRGBの数値を減算したものに変更します。
赤の場合、一般的なRGBは、255,0,0のため、256-255,256-0,256-0です。
PythonScriptをコンパイルします。
[Statistics]ウィンドウを表示します。
[Machine & Process Node]タブにある[Parametric Lathe - State]グラフの[Idle]の色が、青から赤に変化したことがわかります。
現在のPythonScriptの状態で、ファイルを保存し、開き直した時、[出力]ウィンドウにはエラーメッセージが表示されます。
ファイルを開き直した時、統計情報のダッシュボードが反映されるより先に、PythonScriptのコンパイルが完了することが原因です。
統計情報のダッシュボードに取得する情報がないため、エラーが発生します。
エラーを防ぐため、PythonScriptに条件を追記します。
Geminiを新規で立ち上げた時、統計情報のダッシュボードが設定されていない状態でも、ダッシュボード、タブ、グラフは1つずつ存在しています。
グラフの種類は設定されていないため、統計情報のダッシュボードが反映されているかの判断基準とします。
「dash=」の次の行に、if dash.Tabs[0].Charts[0].ChartType != 0:と記述します。
0は、グラフの種類が設定されていないことを示します。
グラフの種類については、[ヘルプ]タブ-[パイソンAPI]-[vcStatisticsChart]-[ChartType]のDescription欄にある[Statistics Constants]を選択し、[Chart Types]で確認してください。
「tab =」以下の行をすべて選択し、tabキーを押すことで、段落を1つ下げることができます。
PythonScriptをコンパイルします。
[ファイル]タブを選択し、[名前をつけて保存]で任意の場所に保存します。
ctrlキーとNキーを同時に押し、レイアウトを削除します。
保存したファイルを開きます。
[出力]ウィンドウに、エラーメッセージが表示されないことがわかります。
統計情報のダッシュボードで表示できるグラフのデータの色を変更する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

コンベアを作ってシーケンサと繋いでみよう

オリジナルのコンベアを作って、シーケンサと連携してシミュレーションする方法
https://youtu.be/p0kOs-CQnjY
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_008.zip

PLCに対応したコンポーネントを作成し、テストする方法を説明します。
コンベアをインポートし、ラダープログラムでテストします。
Geminiの操作をする前に、GX Works3のプロジェクトを開いてください。
Geminiにもどります。
[モデリング]タブに移動します。
コンポーネントのモデリングをします。
コンベアのジオメトリをインポートします。
コンポーネントに含む要素にチェックをつけ、
[インポート]ボタンをクリックします。
インポートしたジオメトリは、3Dワールドに、新しいコンポーネントとして追加されます。
コンポーネントをコンベアのように動作させるため、[ウィザード]を展開し、[コンベア]をクリックします。
デフォルトのオプションを使用します。
[パス開始時に作成者を追加]にチェックはつけず、[コンベアの動作を作成する]をクリックします。
コンポーネントを、コンベアのように動作させるために必要な設定が追加されました。
コンベアウィンドウを閉じ、
コンポーネントグラフを確認します。
Satisticsが追加され、モノの流れと状態を監視することができます。
コンベアの上を製品が流れる経路を設定するパスも設定が追加されています。
コンポーネントをパスの内外に転送するための設定として、InoutとOutputがあります。
inインターフェース、outインターフェースは、コンベアを3Dワールドの他のコンポーネントと、接続することができます。
センサーインターフェースはコンベアと外部センサーを接続することができします。
ブール型シグナルが追加され、パスに接続されているため、動作を制御することができます。
シグナル値がFalseの場合、パスをオフにし、
シグナル値が True の場合、パスをオンにします。
[ホーム]タブに移動します。
コンベアに他のコンポーネントを接続します。
eカタログの[タイプ別モデル]の下にある[Feeders]を展開し、[Visual Components]をクリックします。
[Shape Feeder]をダブルクリックします。
フィーダーとコンベアがに接続されます。
コンベアを選択し、表示されるツールバーの[クローン]をクリックします。
コンベアのコピーを作成し、接続することができます。
シミュレーションを再生します。
コンベアからコンベアに箱が流れます。
シミュレーションをリセットし、センサーをコンベアに接続します。
eカタログの[Conveyor Utilities]を展開し、[Visual Components]をクリックします。
3Dワールドに[Conveyor Sensor]を追加します。
PnP接続で、センサーをパスに直接接続し、パス上でセンサーをドラッグすることで、センサー位置を変更することができます。
[接続性]タブに移動します。
[接続性]タブが表示されない場合、[ファイル]タブに移動し、
[オプション]をクリックし、[アドオン]の接続性が有効であることを確認します。
無効になっている場合は有効にします。
設定を変更すると再起動が必要になるため、[OK]をクリックし、Geminiを再起動します。
再起動する場合、コンポーネントとレイアウトを保存する必要があります。
[接続性]タブに移動し、[接続性]コンフィグのMITSUBISHI ELECTRIC FAを選択し、
新しいサーバー接続を追加します。
GX Works3の画面を開き、シミュレーションを開始してください。
シミュレーションの開始が確認できたら、Geminiに戻ります。
一般設定のPC側インターフェースは接続するシミュレータを設定します。
今回はGX Works3と接続するので、設定はデフォルトです。
通信設定のCPUシリーズ・CPUタイプ・システム番号・号機番号の設定もデフォルトです。
戦闘デバイス・点数設定では接続で使用するデバイスのを設定します。
デフォルトに加え、先頭デバイスにM0と設定します。
［接続をテスト］をクリックします。
接続に成功しました。というウィンドウが表示されますので、OKをクリックします。
[適用]をクリックします。
シミュレーションの入力と出力をサーバーのデバイスとペアリングします。
接続性コンフィグの、[サーバ]の横にある白丸をクリックし、緑色にしてサーバと接続します。
[シミュレーションからサーバーへ]を選択し、右クリックでメニューを開き、[変数を追加]を選択します。
Gemini側の構造が表示されていないまたは古い情報が表示されている場合は、右クリックしシミュレーション構造の再読み込みを選択してください。
Gemini側は、[Conveyor Sensor]を展開し、[SensorBooleanSignal]をクリックし、
PLC側は、[X0]を展開し、[X0]をクリックします。
[選択済みペア]をクリックし、ペアリングします。
接続済み変数に接続が追加されます。
ウィンドウを閉じます。
[サーバーからシミュレーションへ]を選択し、右クリックでメニューを開き、[変数を追加]を選択します。
変数を追加します。
センサーが取り付けられているコンベアを展開し、PowerOnSignalをクリックします。
PLC側では、[M0]を展開し、[M0]をクリックします。
[選択済みペア]をクリックし、ペアリングします。
接続されていることを確認するため、[接続済変数]タブに移動します。
[シミュレーションからサーバーへ]では、センサーからの入力を、PLCに送信しています。
[サーバーからシミュレーションへ]では、PLCからコンベアをオン、またはオフにするシグナルを送信します。
シミュレーションを再生します。
コンベアのシグナルがTrueなので、箱が流れます。
センサーが箱を検出し、センサーのシグナルがTrueになり、コンベアのシグナルはFalseになりました。
PLCプログラムにサーバーをリセットするタイマーがあるため、箱が再度、コンベアを流れ始めました。
GeminiとGX Works3を両方表示し、比較します。
ワークを生成する感覚が短く、センサーの検知が途切れないため、プログラムは失敗しています。
シミュレーションをリセットし、フィーダーを選択します。
[CreationInterval]で、ワークを生成する間隔を変更します。
2sから8sに変更します。
シミュレーションを再生します。
センサーが箱を検出しました。
コンベアの流れが停止しています。
2つ目の箱と3つ目の箱が、同時に動き出しました。
シミュレーションを確認することで、PLCプログラムを修正する必要があることが分かります。
PLCに対応したコンポーネントを作成し、テストする方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

コンポーネントが衝突するときの反発を定義しよう

物理的なコンポーネントの反発や弾性を定義する方法
https://youtu.be/5FqmqTovFvA
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_043.zip

2つのコンポーネントが衝突する場合、どのように弾むかを定義する方法を説明します。
eカタログの[タイプ別モデル]-[Physics]をクリックします。
[Block Collider]、[Cylinder Collider]を追加します。
円柱をブロックの上に移動します。
[ツール]-[スナップ]をクリックします。
円柱をブロックの上面中央にスナップします。
[マニピュレーション]-[移動ツール]を使用します。
円柱をZ軸に沿って上に移動します。
[コンポーネントプロパティ]のZ座標を1300に設定します。
シミュレーションを実行すると、シリンダーが落下せず、重力の影響を受けていないことがわかります。
シミュレーションをリセットし、重力の設定をします。
円柱を選択した状態で、[コンポーネントプロパティ]ウィンドウで、[PhysicsEntity]タブを選択します。
[物理タイプ]を[機構]から[物理内]に変更します。
[シミュレーションコントロール]のシミュレーション速度係数を0.5に設定します。
シミュレーションの実行速度が遅くなるため、落下の動作が見やすくなります。
シミュレーションを実行すると、円柱が落下し、ブロックに衝突します。
円柱とブロックがどのように衝突したのか、詳細を確認していきます。
シミュレーションをリセットし、再度実行すると、少し跳ね返りがあることがわかります。
この跳ね返りが反発です。
[モデリング]タブを開きます。
[コンポーネントグラフ]ウィンドウで、[Cylinder Collider]-[ビヘイビア]-[PhysicsEntity]を選択します。
[プロパティ]ウィンドウの[反発]が、デフォルトで0.1に設定されています。
反発係数は、0から1の間で入力できます。
[反発]に0を入力すると、非弾性衝突になるため、跳ね返りがなくなります。
シミュレーションを実行すると、円柱が跳ね返らず、ブロックの上に留まります。
シミュレーションをリセットします。
[反発]に「1」を入力すると、完全弾性衝突になるため、跳ね返ります。
シミュレーションを実行すると、円柱が大きく跳ね返ります。
シミュレーションをリセットします。
[反発]に0.5を入力します。
[反発]に1を入力した場合に比べ、跳ね返りが約半分になります。
シミュレーションを実行すると、少し跳ね返り、ブロックの上に留まります。
シミュレーションをリセットします。
ブロックを選択します。
[コンポーネントグラフ]ウィンドウで、[Block Collider]-[ビヘイビア]-[PhysicsEntity]を選択します。
[プロパティ]ウィンドウの[物理タイプ]を[物理外]に設定します。
シミュレーションを実行すると、円柱がブロックをすり抜け、跳ね返ります。
[物理タイプ]を[物理外]に設定すると、ブロックが物理の影響を受けないため、円柱はすり抜け、床に衝突し跳ね返ります。
コンベアを作成し、コンベア上に円柱が落下する場合の動作を確認します。
[ホーム]タブを開きます。
eカタログの[タイプ別モデル]-[Physics]-[Conveyor(Physics)]を選択します。
[Cylinder Collider]を選択し、円柱を1つ追加します。
[ツール]-[スナップ]をクリックします。
円柱をコンベアの上面中央に配置します。
移動ツールを使用します。
円柱をZ軸に沿って上に移動します。
X軸に沿って約40度回転します。
シミュレーションを実行すると、[物理タイプ]が[機構]のため、落下しないことがわかります。
シミュレーションをリセットします。
[コンポーネントプロパティ]ウィンドウで、[物理タイプ]を[物理内]に変更します。
シミュレーションを実行します。
円柱がコンベアに衝突した後、少し跳ね返り、コンベアの上を流れます。
円柱が、完全弾性反発で落下する場合の動作を確認します。
[モデリング]タブを開きます。
[コンポーネントグラフ]ウィンドウで、[Cylinder Collider #2]-[ビヘイビア]-[PhysicsEntity]を選択します。
[プロパティ]ウィンドウの[反発]を、デフォルトの0.1から1に変更します。
シミュレーションを実行すると、円柱が大きく跳ね返ります。
また、[プロパティ]ウィンドウの[静止摩擦]、[動摩擦]に数値が入力されており、摩擦が発生していることがわかります。
シミュレーションをリセットし、[反発]を0.3に変更します。
シミュレーションを実行します。
[反発]を1にした場合に比べ、円柱の跳ね返りが小さくなり、コンベアの上を流れることがわかります。
コンポーネントに反発を定義する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

コンポーネントのノードを選択して設定を確認しよう

オリジナルの装置などのコンポーネントを作成する時にノード/リンクを選択する方法
https://youtu.be/IlxFybVNWbA

コンポーネント内のノードを選択する方法を説明します。
コンポーネント内には、ビヘイビアやフィーチャなどの情報が含まれています。
この情報をノードと言い、ツリー構造で管理します。
ノードで情報を管理することによって、構造が複雑な場合でも、全体像を把握しやすくなります。
また、ツリー構造のスタート地点を、ルートやルートノードと言います。
各コンポーネントには、少なくとも1つのノードとルートが含まれます。
eカタログに移動します。
[タイプ別モデル]を展開します。
[Robots]を展開します。
[Visual Components]を選択します。
[Generic Articulated Robot]を3Dワールドに追加します。
[モデリング]タブを開きます。
モデリングビューでは、フィーチャを直接選択することができます。
コンポーネントの形状を構成する部品をフィーチャと言います。
フィーチャはノードに含まれ、コンポーネントのノードとフィーチャのノードは、値などを相互にリンクさせることができます。
ロボットの中央をクリックして選択します。
コントロールキーを押しながら他のフィーチャを選択し、選択範囲に追加や削除ができます。
また、[マニピュレーション]-[選択]で、フィーチャを選択できます。
[長方形選択]や[フリーフォーム選択]を選択すると、指定したエリア内で、複数のフィーチャを選択できます。
ノードを選択する場合は、コンポーネントかフィーチャを選択します。
[コンポーネントグラフ]ウィンドウに、選択されたノードが表示されます。
追加したロボットは、一般的な多関節のロボットで、6つのノードがあります。
Axis1、2、3、4、5の5つのジョイントがあります。
Axis5を展開すると、Axis6があります。
ロボットや人間などの関節部分をジョイントと言います。
ジョイントはノードで定義され、ビヘイビアでロボットコントローラ、またはサーボコントローラを割り当てることで、駆動します。
ノードやリンクを選択すると、ジオメトリが3Dワールド上で青色にハイライトされます。
Axis2を選択します。
対象のジオメトリが青色、子ノードが紫色でハイライトされていることがわかります。
[コンポーネントグラフ]ウィンドウでノードを直接選択でき、フィーチャを直接クリックするとノードを選択できます。
ダブルクリックすると、フィーチャではなく、フィーチャのノードが選択されます。
モデリングビューでフィーチャを選択する場合、ワンクリックで直接選択するか、ダブルクリックでそのノードを選択することができます。
コンポーネント内のノードを選択する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

コンポーネントパスセンサーを使ってみよう

コンベア上を移動する製品のみを検出するコンポーネントパスセンサーを使用する方法
（関連動画：レイキャストセンサーを使ってみよう、ボリュームセンサーを使ってみよう、ウィザードを使ってコンベアを作ってみよう、ツーウェイパスを使ってみよう）
https://youtu.be/QaXF1AF4Cnk
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_176.zip

コンポーネントパスセンサーの使用方法について説明します。
コンポーネントパスセンサーとは、パスと呼ばれるコンポーネントを格納する動作設定に格納されているもののみ、検出するセンサーです。
他の種類のセンサーについては、動画「レイキャストセンサーを使ってみよう」、「ボリュームセンサーを使ってみよう」を参照してください。
事前ファイル「PathSensor_before.vcmx」を開きます。
シミュレーションを実行します。
ワークが生成され、コンベア上を移動していることがわかります。
シミュレーションをリセットします。
オリジナルのコンベアを簡単に作成する方法については、動画「ウィザードを使ってコンベアを作ってみよう」を参照してください。
コンベアの内部設定の詳細については、動画「ツーウェイパスを使ってみよう」を参照してください。
ワークが、コンベアの中央に到達した時、ランプを点灯させます。
センサーが検出する位置を設定するため、フレームを追加します。
フレームとは、3Dワールド上で、位置と方向を定義する基準点です。
コンベアを選択し、[モデリング]タブを開きます。
[ジオメトリ]グループの[フィーチャ]を展開し、[その他]から[フレーム]を選択します。
3Dワールドに、フレームが表示されない場合、3Dワールドツールバーの[フレームタイプ]を展開し、フレームにチェックを付けます。
[フレームタイプ]アイコンが透明な場合、機能は無効となっているため、アイコンを選択し、有効にする必要があります。
3Dワールドに、フレームを表示できます。
[フィーチャプロパティ]ウィンドウで、[名前]をMidに変更します。
フレームを移動させます。
Midを選択した状態で、[ツール]グループの[スナップ]を選択します。
[スナップ]は、選択しているものを、3Dワールドの選択した位置に移動できる機能です。
選択しているものの、原点を基準に移動できます。
コンベアの中央を選択します。
ワークを検出するため、センサーを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[センサー]から[パス]を選択します。
センサーの位置を、フレームを選択して、定義します。
[プロパティ]ウィンドウの[フレーム]で、Midを選択します。
ワークの検出を通知する場合、[ブールシグナル]を設定します。
ブールシグナルは、ON/OFFの値を送受信できるシグナルです。
ランプに、ワークの検出を送信し、点灯/消灯するため、ブールシグナルを設定します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[ブール型]を選択します。
[プロパティ]ウィンドウの[名前]をDetectに変更します。
[コンポーネントグラフ]ウィンドウで、[ComponentPathSensor]を選択します。
[ブールシグナル]で、Detectを選択します。
現時点では、シミュレーションを実行しても、ワークを検出しません。
コンポーネントパスセンサーを使用する場合、パスに設定を追加する必要があります。
[コンポーネントグラフ]ウィンドウの[OneWayPath]を選択します。
パスとセンサーを接続するため、[プロパティ]ウィンドウの[センサー]、[+]アイコンを選択します。
[Add Sensors items]ウィンドウで、ComponentPathSensorを選択します。
コンポーネントパスセンサーの検出する位置は、パスの経路内に存在する必要があります。
パスの経路にMidを追加するため、[パス]、[+]アイコンを選択します。
[Add Path items]ウィンドウでMidを選択します。
[パス]のフレーム名にカーソルを合わせ、表示される矢印を選択することで、経路の順番を変更できます。
経路の順番は、Start、Mid、Endです。
センサーがワークを検出した時、ランプを点灯させるため、シグナル同士を接続します。
[コンポーネントグラフ]ウィンドウでConveyorを選択します。
[接続]グループの[シグナル]を選択することで、3Dワールドと、画面右側にシグナルウィンドウが表示されます。
[Conveyor]の[Detect]を選択した状態で、[LED Indicator Light]の[BooleanSignal]を選択します。
シミュレーションを実行します。
ワークがMidに到達した時、ランプが点灯していることがわかります。
現在、ワークの最初の辺がMidに到達した時、センサーシグナルがONになり、最後の辺がMidに到達した時、センサーシグナルがOFFになります。
シミュレーションをリセットします。
センサーが検出するワークの位置を変更できます。
[コンポーネントグラフ]ウィンドウで、ComponentPathSensorを選択します。
[プロパティ]ウィンドウの[トリガー]で、センサーシグナルをONにするワークの位置を変更できます。
リーディングエッジは、最初の辺、原点は、コンポーネントの原点、トレーリングエッジは、最後の辺です。
なしを選択することで、センサーを無効化できます。
[リセット]は、センサーシグナルをOFFにするワークの位置を変更できます。
[トリガー]を原点、[リセット]をなしに変更します。
シミュレーションを実行します。
ワークの原点は、底面の中心にあるため、ワークの中心がMidを通過した時、センサーシグナルがONになります。
[リセット]をなしとしたため、シミュレーションをリセットするまで、センサーシグナルは、OFFになりません。
シミュレーションをリセットします。
センサーの検出位置を[フレーム]以外で設定する方法を説明します。
コンベアの[コンポーネントグラフ]ウィンドウを表示し、ComponentPathSensorを選択します。
[プロパティ]ウィンドウで、[リセット]をトレーリングエッジに変更し、センサーシグナルの値がリセットされるようにします。
[距離]に200と入力します。
[距離]に数値を入力することで、パスのStart位置からの距離で、ワークの検出位置を設定できます。
コンベアの長さは2000mmです。
シミュレーションを実行します。
Startから200mmの位置でセンサーシグナルがONになったことがわかります。
シミュレーションをリセットします。
[距離]に0より大きい数値を入力後、0に戻した場合、[フレーム]で設定した位置で検出しません。
[フレーム]を設定し直す必要があるため、注意が必要です。
[ブールシグナル値]を無効にした場合、ブールシグナルの値が反転します。
検出したワークをコンポーネントとして送受信する方法を説明します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[コンポーネント]を選択します。
コンポーネントシグナルは、コンポーネントを値として送受信できるシグナルです。
[プロパティ]ウィンドウの[名前]をWorkに変更します。
[コンポーネントグラフ]ウィンドウで、ComponentPathSensorを選択します。
[プロパティ]ウィンドウの[コンポーネントシグナル]で、Workを選択します。
検出したワークの情報を表示するため、PythonScriptを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
Pythonスクリプトエディタが自動的に開きます。
シグナルの値が変化した時、処理を実行するため、関数OnSignalに記述します。
関数OnSignalの引数signalには、PythonScriptに接続されたシグナルが入ります。
if signal.Value != None:と記述し、センサーが検出した時、以下の処理を実行します。
print signal.Value.Nameと記述することで、検出したコンポーネントの名前を[出力]ウィンドウに表示できます。
else:と記述し、センサーが検出していない時の処理を設定します。
print "None"と記述し、文字列でNoneと表示します。
PythonScriptをコンパイルします。
PythonScriptとシグナルを接続します。
[コンポーネントグラフ]ウィンドウで、Workを選択します。
[プロパティ]ウィンドウの[接続]、[+]アイコンを選択します。
[Add Connections items]ウィンドウで、PythonScriptを選択することで、接続できます。
シミュレーションを実行します。
[出力]ウィンドウにワークのコンポーネント名と、Noneという文字が表示されたことがわかります。
シミュレーションをリセットします。
コンポーネントパスセンサーの使用方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

コンポーネントを保存しよう

Geminiで作成したコンポーネント（装置やワークなど）を保存して、オリジナルのeカタログに設定する方法
https://youtu.be/Ytq80ru1SQQ

コンポーネントを保存する方法を説明します。
コンポーネントの保存方法は、レイアウトを保存する方法とコンポーネントを保存する方法があります。
レイアウトを保存する場合は、コンポーネントの配置座標やプロパティなどの情報を含めることができます。
[ファイル]タブの[保存]や[名前をつけて保存]を選択し、保存します。
コンポーネントを保存する場合は、コンポーネントそのものを1つのモデルとして保存します。
保存したコンポーネントは、オリジナルのeカタログとして使用することや、フィーダーが生成する部品として指定することができるようになります。
[モデリング]タブの[コンポーネント]で[保存]や[名前をつけて保存]を選択し、保存します。
今回は、Geminiで作成したコンポーネントやインポートしたCADを「コンポーネント」として保存する方法を説明します。
[モデリング]タブを開きます。
[コンポーネント]-[新規]を選択し、コンポーネントを作成します。
[ジオメトリ]-[フィーチャ]-[ブロック]を選択し、ブロックを作成します。
コンポーネントを保存します。
[コンポーネント]-[保存]、もしくは、[名前をつけて保存]を選択し、保存します。
[保存]は、コンポーネントを既存のファイルに保存します。
例えば、コンポーネントAに変更を加えた後、その変更を同じコンポーネントAに上書き保存する場合に選択します。
[名前をつけて保存]は、コンポーネントを新規ファイルとして保存します。
例えば、コンポーネントAに変更を加えた後、その変更を新しいコンポーネントとして、別名で保存する場合に選択します。
今回は、[名前をつけて保存]を選択します。
[コンポーネントを名前をつけて保存]ウィンドウで、保存時の情報を設定します。
保存した情報は、オリジナルのeカタログとして保存した場合、eカタログのツリー上の[メタデータの表示]に反映され、編集することができます。
また、eカタログから3Dワールド上にドラッグ＆ドロップした後の[コンポーネントプロパティ]のメタデータに反映され、確認することができます。
[名前]は、コンポーネントの名前を設定します。
[説明]は、コンポーネントに説明文を設定します。
メタデータ上では、[Description]という項目名に反映されます。
[タイプ]は、ドロップダウンからConveyor、Robotsなどの製品カテゴリを選択します。
タイプの項目名は、eカタログの既存のタイプが表示されます。
[タグ]は、ブロック、箱、ワークなどのキーワードを設定します。
[最大ペイロード]や[Reach]はロボットなどで使用します。
[最大ペイロード]は、コンポーネントの最大積載量を設定します。
[Reach]は、コンポーネントの到達可能範囲を設定します。
[アイコン]は、Gemini内で表示するためのコンポーネントのスナップショットです。
コンポーネントのスナップショットを撮る際のカメラ位置は固定です。
[ファイル]は、保存場所を指定します。
[VCID]は、コンポーネントを識別するためのIDです。
新しいIDは、コンポーネントが保存される度に、アプリケーションによって生成されます。
[新規VCID]のチェックを外すと、新しいIDが生成されないようにできます。
新規コンポーネントのようにVCIDを元々持っていない場合は、チェックを外すことはできません。
[修正済み]は、最終更新日が自動で入力されます。
[メーカー]は、コンポーネントの作成元のメーカーを設定します。
[製作者]は、コンポーネントの作成者を設定します。
[メールアドレス]は、作成元のメールアドレスを設定します。
[ウェブサイト]は、作成元のウェブサイトを設定します。
[企業ロゴ]は、作成元の企業のロゴを設定します。
[変更]ボタンを選択すると、画像選択ダイアログが表示されるため、任意の画像を選択することで、ロゴを設定できます。
[修正]は、コンポーネントのバージョン番号を設定します。
1.0、2.0などの番号を入力します。
[自動インクリメントリビジョン]にチェックを入れると、自動でバージョン番号を上げることができます。
[推奨されません]にチェックを入れると、eカタログでコンポーネントを非表示にできます。
今回は、[名前]のみ変更します。
[名前]にMy Blockと入力し、コンポーネントの名前をMy Blockにします。
[名前をつけて保存]ボタンをクリックします。
保存ダイアログが表示されるため、任意の場所に保存します。
今回は、eカタログに自作のモデルを表示するため、[My Models]に保存します。
[ドキュメント]-[MITSUBISHI]-[Gemini]-[1.45]-[My Models]を開きます。
ファイル名はそのままにし、保存します。
[ホーム]タブを開きます。
eカタログの[マイモデル]を選択すると、先ほど保存したブロックが表示されます。
[マイモデル]が表示されない場合は、[コレクション]の横の[＋]ボタンをクリックし、[ソースを編集]を選択します。
[ソース]ダイアログが表示されるため、[マイモデル]の[表示]にチェックを入れ、ダイアログを閉じると、eカタログに[マイモデル]が追加されます。
保存時に[推奨されません]にチェックを入れると、コンポーネントはeカタログに表示されず、合計アイテム数にも含まれません。
eカタログに表示したい場合は、eカタログのコレクション内で右クリックし、[非推奨コンポーネントを表示]にチェックを入れます。
チェックを入れると、合計アイテム数にも追加されます。
保存時に設定したメタデータを確認します。
3Dワールドのコンポーネントを選択します。
[コンポーネントプロパティ]ウィンドウのタグアイコンを選択します。
[メタデータを表示]ダイアログが表示されます。
[VCID]や[Name]などのデータを確認できます。
なお、My Models以外に保存した場合は、[メタデータを表示]に反映されません。
[メタデータを表示]ダイアログを閉じます。
保存時に設定したメタデータを編集します。
eカタログのMy Blockを選択します。
右クリックし、[メタデータを編集]を選択します。
[メタデータを編集]ダイアログが表示されます。
編集したいフィールドを選択すると、文字や値を変更できます。
VCIDはコンポーネントの識別IDであり、読み取り専用となります。
[タグ]にブロックと入力します。
[OK]ボタンをクリックします。
[コンポーネントプロパティ]ウィンドウのタグアイコンを選択し、[メタデータを表示]ダイアログを表示します。
[タグ]を確認すると、ブロックが入力されていることがわかります。
コンポーネントを保存する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

サーボをPythonで制御しよう(1/2)

オリジナルの装置の駆動を、パイソンスクリプト（Python）で制御する方法。（setJointTarget、CalcMotionTime、setMotionTime、move、moveJoint、moveImmediate）
https://youtu.be/a7knI4no4YU
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_094_p1.zip

サーボをPythonで制御する方法を説明します。
Pythonを使用して、サーボに割り当てられたジョイントの動きや目標値を管理することができます。
動画内で使用するGeminiのファイルをダウンロードします。
ファイル名は、[Control Servo - Part1.vcmx]です。
ファイルを開くと、Geminiにコンポーネントが表示されます。
[モデリング]タブを開きます。
3Dワールドのコンポーネントを選択します。
[コンポーネントグラフ]ウィンドウのノードツリーをすべて展開するため、「＋」を選択します。
ビヘイビアの[Servo]は、コンポーネントを駆動させるためのサーボコントローラです。
[プロパティ]ウィンドウの[ジョイント]にJoint_XとJoint_Yが設定されています。
[Link1]の[リンクプロパティ]ウィンドウの[Name]は、[Joint_X]です。
[Link2]の[リンクプロパティ]ウィンドウの[Name]は、[Joint_Y]です。
つまり、ServoでLink1とLink2を駆動できます。
Link1を動かすと、子ノードであるLink2も動きます。
Link2を動かすと、Link2だけ動きます。
Link1はX軸に沿って動き、Link2はY軸に沿って動きます。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
ジョイントの目標値を設定して、サーボとそのジョイントを制御する方法について説明します。
例えば、vcServoControllerのsetJointTarget()メソッドを使用すると、サーボで制御するジョイントの目標値を定義できます。
OnSignal関数を削除します。
OnRun内のpassを削除します。
「comp = getComponent()」と記述し、Pythonスクリプトを設定しているコンポーネントを取得しています。
「servo = comp.findBehaviour("Servo")」と記述し、ビヘイビアのServoを取得します。
「servo.setJointTarget」と記述し、ジョイントの移動先を指定します。
引数の1番目で動かしたいジョイントのインデックス番号を指定し、引数の2番目で目標値を指定します。
サーボのジョイントの0番目であるJoint_Xを動かすため、引数の1つ目は、0にします。
引数の2つ目は、Joint_Xを500mmに動かすため、500.0にします。
「servo.setJointTarget」を再度記述します。
サーボのジョイントの1番目であるJoint_Yを動かすため、引数の1つ目は、1にします。
引数の2つ目は、Joint_Yを0mmのままにするため、0.0にします。
「servo.move()」と記述し、setJointTargetで指定した移動先まで、全てのジョイントを移動します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
Joint_Xは500mmの位置に移動します。
Joint_YはJoint_Xの子ノードのため、X軸方向に500mm移動しますが、Y軸方向には0mmのまま動きません。
シミュレーションをリセットします。
ジョイントの値を、別のジョイントを動かす条件として使用する方法について説明します。
例えば、vcServoControllerのgetJointValue()メソッドとgetJointTarget()メソッドを使用して、ジョイントを順番に動かす条件を定義できます。
「condition」と記述し、指定した条件でジョイントが動くようにします。
「servo.getJointTarget(0)==servo.getJointValue(0)」と記述し、Joint_Xの目標値と現在値が一致した場合の処理をします。
今回は、Joint_XのsetJointTargetを500にしているため、Joint_Xが500mmの位置になった場合が条件となります。
servo.getJointTargetとservo.getJointValueは、def文の関数で定義する必要がありますが、lambdaを記述することで、関数を省略できます。
「servo.setJointTarget」と記述し、ジョイントの移動先を指定します。
サーボのジョイントの1番目であるJoint_Yを動かすため、引数の1つ目は、1にします。
引数の2つ目は、Joint_Yを500mm動かすため、500.0にします。
「servo.move()」と記述し、setJointTargetで指定した移動先まで、全てのジョイントを移動します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
Joint_Xは500mmの位置に移動します。
Joint_Xの移動後、Joint_Yが500mmの位置に移動します。
シミュレーションをリセットします。
サーボの動作時間を取得して、サーボとそのジョイントを制御する方法について説明します。
ジョイントの目標値を取得し、目標値までの動作時間を計算することができます。
また、サーボの動作時間を設定することで、その時間内に動作が完了するようにジョイントの速度を調整することができます。
例えば、vcServoControllerのcalcMotionTime()メソッドとsetMotionTime()メソッドを使用して、ジョイントの動作時間を計算し、設定することができます。
9行目以降を削除します。
「time = servo.calcMotionTime()」と記述し、移動先まで到達する時間を算出します。
「print "Original cycle time", time」と記述し、移動先まで到達する時間を表示します。
「time += 2」と記述し、移動先までの到達時間を2秒追加します。
「servo.setMotionTime(time)」と記述し、本来の到達時間プラス2秒の時間を指定します。
「print "New cycle time: ", servo.calcMotionTime()」と記述し、移動先まで到達する新しい時間を表示します。
「servo.move()」と記述し、setJointTargetで指定した移動先まで、全てのジョイントを移動します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
Joint_Xは500mmの位置に移動します。
[出力]ウィンドウにJoint_Xが500mm移動するまでの本来の到達時間と、プラス2秒の時間が表示されます。
Joint_Xが、[出力]ウィンドウに表示された新しい時間をかけて移動することがわかります。
シミュレーションをリセットします。
ジョイントの目標値を使用せず、サーボとそのジョイントを制御する方法について説明します。
例えば、vcServoControllerのmoveImmediate()メソッドを使えば、シミュレーション時間ゼロでジョイントを目標値まで動かすことができます。
また、moveJoint()メソッドを使って特定のジョイントを動かすこともできます。
6行目以降をコメントアウトし、コードを無効化します。
コメントアウトするには、アポストロフィーをコメントアウトしたいソースコードの最初と最後に3つずつ付けます。
「servo.moveJoint(0,800.0)」と記述し、Joint_Xを800mmの位置に移動します。
「servo.moveJoint(1,500.0)」と記述し、Joint_Yを500mmの位置に移動します。
「servo.moveImmediate」と記述し、シミュレーション時間ゼロでジョイントを即座に動かします。
Joint_XとJoint_Yの2つのジョイントを動かすため、引数の1つ目にJoint_Xの目標値の0.0、引数の2つ目にJoint_Yの目標値の0.0を入力します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
Joint_Xが800mmの位置に移動します。
Joint_Yが500mmの位置に移動します。
Joint_XとJoint_Yが0mmの位置に即座に移動します。
シミュレーションをリセットします。
サーボをPythonで制御する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

サーボをPythonで制御しよう(2/2)

オリジナルの装置の駆動を、パイソンスクリプト（Python）で制御する方法で、駆動の状態に応じて動作を変更する。（OnHeartbeat）
https://youtu.be/bsr2q2ypPa0
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_094_p2.zip

サーボをPythonで制御する方法を説明します。
パート1では、制御方法を1つずつPythonスクリプトに記述し、シミュレーションを実行して動作を確認しました。
パート2では、引き続き制御方法をPythonスクリプトに記述し、動作を確認していきます。
パート1で使用したファイル、もしくは、[Control Servo - Part1_after.vcmx]をダウンロードし、開きます。
[モデリング]タブを開きます。
3Dワールドのコンポーネントを選択します。
[コンポーネントグラフ]ウィンドウのノードツリーをすべて展開するため、「＋」を選択します。
OnHeartbeatイベントでサーボコントローラのパルスを使用して、サーボとそのジョイントを制御する方法について説明します。
[コンポーネントグラフ]ウィンドウの[Servo]を選択します。
[プロパティ]ウィンドウの[パルスを使用]にチェックを入れます。
パルスは、物体の計測や検知ができる、ONOFF信号です。
パルスを使用することで、移動中・停止中などのコンポーネントの動作ステータスを取得できます。
[パルス時間]は0.0015にします。
[コンポーネントグラフ]ウィンドウのPythonScriptを開きます。
OnRun内を削除します。
comp = getComponent()と記述し、Pythonスクリプトを設定しているコンポーネントを取得しています。
servo = comp.findBehaviour("Servo")と記述し、ビヘイビアのServoを取得します。
servo.OnHeartbeat = addNewTargetと記述し、サーボの動作ステータスが変わるとaddNewTargetという関数を呼び出します。
targets = Noneと記述し、空のtarget変数を用意します。
def addNewTargetと記述し、addNewTargetの関数を作成します。
引数は、servo,event_typeとします。
最初に定義した空のtargets変数に値を上書きしていくため、グローバル変数を使用します。
グローバル変数は、関数の外部の値やソースコードを参照したり、値を代入できます。
global targetsと記述し、targetsという名前のグローバル変数を定義します。
sim = getSimulation()と記述し、シミュレーション中の情報を取得します。
if event_type == VC_CONTROLLER_STARTと記述し、ジョイントの動作が開始した状態を動作条件とします。
print "The servo has started at:", sim.SimTimeと記述し、ジョイントの移動開始時間を取得し、[出力]ウィンドウに表示します。
elif event_type == VC_CONTROLLER_END:と記述し、ジョイントの動作が完了した状態を動作条件とします。
print "The servo has ended at:", sim.SimTimeと記述し、ジョイントの移動後の時間を取得し、[出力]ウィンドウに表示します。
ジョイントの位置によって、targetsに格納する変数を変更していきます。
if servo.getJointTarget(0) == 0 and servo.getJointTarget(1) == 0:と記述し、Joint_XとJoint_Yが0mmを目標値としている場合を条件とします。
targets = (500,0)と記述し、targetsに500と0を格納します。
elif servo.getJointTarget(0) == 500 and servo.getJointTarget(1) == 0:と記述し、Joint_Xが500mm、Joint_Yが0mmを目標値としている場合を条件とします。
if len(targets) < 3:targets = (500,500)と記述し、targetsの要素が2つ以下の場合、targetsに500を2つ格納します。
else:targets = (0,0)と記述し、targetsの要素が3つ以上の場合、targetsに0を2つ格納します。
elif servo.getJointTarget(0) == 500 and servo.getJointTarget(1) == 500:と記述し、Joint_XとJoint_Yが500mmを目標値としている場合を条件とします。
targets = (500,0,-1)と記述し、targetsに500と0と-1を格納します。
条件を元にジョイントの移動先を指定します。
for i in range(servo.JointCount):と記述し、変数のiにジョイントの数を格納します。
今回は、Joint_XとJoint_Yの2つのジョイントがあるため、iには0と1が格納されます。
servo.setJointTargetと記述し、ジョイントの移動先を指定します。
Joint_XとJoint_Yを動かすため、iと記述し、0番目と1番目が格納されるようにします。
Joint_XとJoint_Yは、if文内のtargetsの値だけ動かすため、targets[i]と記述します。
例えば、Joint_XとJoint_Yが0mmのとき、targets = (500,0)の値を取得するため、targets[0]である500mmとtargest[1]である0mm動かします。
resumeRun()と記述し、OnRun関数の実行を開始します。
OnRun内にジョイントを動かすためのソースコードを記述します。
while True:と記述し、ループ処理します。
servo.move()と記述し、setJointTargetで指定した移動先まで、全てのジョイントを移動します。
suspendRun()と記述し、OnRun関数の実行を停止します。
スタートの位置では、ジョイントの動作が完了した状態にならず、VC_CONTROLLER_ENDがトリガーできないため、0mmまで移動したことにします。
for i in range(servo.JointCount):と記述し、変数のiにジョイントの数を格納します。
今回は、Joint_XとJoint_Yの2つのジョイントがあるため、iには0と1が格納されます。
servo.setJointTargetと記述し、ジョイントの移動先を指定します。
Joint_XとJoint_Yを動かすため、iと記述し、0番目と1番目が格納されるようにします。
Joint_XとJoint_Yを0mm動かすため、0にします。
これで、ジョイントがスタート位置から0mmまで移動が完了した状態になるため、VC_CONTROLLER_ENDをトリガーできます。
def OnStartと記述し、OnStartの関数を作成します。
OnStartは、シミュレーション実行開始時に処理される関数です。
for i in servo.Joints:と記述し、変数のiにサーボコントローラのジョイントのインデックス番号を0番目から順番に割り当てます。
今回は、サーボジョイントの0番目であるJoint_Xと1番目であるJoint_Yがあるため、0と1が割り当てられます。
print i.Name, i.InitialValueと記述し、ジョイントの名前と最初の位置を表示します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
Joint_XとJoint_Yが0mmからスタートするため、Joint_Xが500mmの位置に移動します。
Joint_Xが500mmまで移動後、targetの要素が2つのため、Joint_Xは500mmのまま、Joint_Yが500mmの位置に移動します。
Joint_Yが500mmまで移動後、Joint_XとJoint_Yは500mmの位置にいるため、Joint_Xは500mmのまま、Joint_Yが0mmの位置に移動します。
また、targetに-1が入るため、targetの要素が3つになります。
Joint_Yが0mmまで移動後、targetの要素が3つのため、Joint_XとJoint_Yが0mmの位置に移動します。
以降、0mmと500mmの間を同様に移動します。
サーボをPythonで制御する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

シミュレーション性能を最適化しよう

レイアウトを作成する上で、シミュレーション性能を上げたい場合に注意すべき点や、役に立つ機能の紹介。
https://youtu.be/JAcRYMchcf0
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_155.zip

本動画では、シミュレーションのパフォーマンスを向上させるため、モデルやフローの設定で注意すべき点について説明します。
まず、使用するモデルの注意点を説明します。
モデルとは、実際の現場を再現するために3Dワールド上に配置するジオメトリのことです。
使用するモデルは、できる限り軽量なものを使用するようにしましょう。
ナットやボルトのような、シミュレーションの動きには関与しない詳細な部分は、削除するのが望ましいです。
このような詳細な部分は、マシンの内側など通常では見えないところにある場合があります。
その場合、"レンダリングモード"を"ワイヤフレーム"や"X線シェーディング"にすると、見つけやすいです。
CADモデルなどは詳細すぎる場合があるため、インポートする時に[モデルをインポート]ウィンドウで、簡略化して軽量になるように設定します。
[モデルをインポート]ウィンドウの、モデルのデータ量に関係する機能について説明します。
"テッセレーションの品質"は、高品質にするほどポリゴンが細かくなり、低品質になるほど粗くなります。
この設定は、できる限り下げてください。
"フィーチャツリー"は、ジオメトリをどういう階層構造でインポートするか定義します。
"完全"は、CADのアセンブリツリーに基づいてフィーチャツリーを作成し、アセンブリツリーの各アイテムが独自のフィーチャになります。
ジオメトリを含むフィーチャは"ジオメトリ"フィーチャを生成し、それ以外は"トランスフォーム"フィーチャを生成します。
"最適化"は、フラットな構造のフィーチャツリーを生成します。
"トランスフォーム"フィーチャは追加されません。
"最小化"は、ジオメトリフィーチャを1つだけ作成します。
干渉チェック、レイキャスト、ボリューム検出などでジオメトリを検出する際は、"最小化"でインポートしたジオメトリが、一番パフォーマンスがよくなります。
"ジオメトリを整理"は、ジオメトリをジオメトリセットに編成する方法を定義します。
ジオメトリセットは、スライス・分解・折りたたむことができます。
"面による"は、ジオメトリの各面を、独自のジオメトリセットとして作成します。
"マテリアルによる"は、1つのメッシュに各色用の独自のジオメトリセットを作成します。
ジオメトリセットごとに1つのマテリアルしか定義できません。
"折りたたみ"は、すべてのメッシュを1つのジオメトリセットにまとめます。
ただし、パフォーマンスを最適化するために、三角形の合計数が10000(または16000) を超えると、新しいジオメトリセットが作成されます。
"数学的データ"は、面ごとに1セットずつジオメトリを整理し、BREPエンティティを三角形のセットに格納することで、ジオメトリとファイルサイズを大きくすることができます。
BREPとは、空間上の閉じた面を使って、3次元ソリッドモデルを表現する方法のことです。
"面による"と"数学的データ"は推奨されておらず、"マテリアルによる"か"折りたたみ"を使うようにしてください。
[モデルをインポート]ウィンドウの"分析"は、今インポートしようとしているモデルのデータ量が確認できます。
[モデルをインポート]ウィンドウの説明は以上になります。
モデルは、インポートした後、更に簡略化することができます。
モデルを簡略化する機能である[円柱化]、[ブロック化]、[簡略化]について説明します。
この3つのコマンドは、ジオメトリを選択した状態で[モデリング]タブ-[ツール]から、または"コンポーネントグラフ"の"ノードフィーチャツリー"でジオメトリを右クリックして表示できます。
[簡略化]は、頂点をマージおよび削除することにより、選択しているフィーチャのデータ数を減らします。
これは、ジオメトリのトポロジーを維持したまま、冗長な頂点を排除し、3Dモデルの表面を構成するポリゴンを集約します。
[円柱化]は、選択しているジオメトリを円柱形状に変換します。
[ブロック化]は、選択しているジオメトリをブロック形状に変換します。
これらのコマンドを実行すると、実行前に戻すことができなくなります。
実行する前に、コピー等のバックアップを用意してください。
シンプルなモデルであれば、コマンドを使って変換する以外にも、[ジオメトリ]を使って自分で作り直す方法もあります。
モデルを簡略化する機能の説明は、以上になります。
モデルを構成するジオメトリの注意点を説明します。
モデルを構成するジオメトリには、"オンデマンドロード"プロパティがあります。
これを有効にしたジオメトリは、表示する必要がある場合にのみ、メモリにロードされます。
つまり、これを有効にしたジオメトリが非表示になると、表示が必要になるまでロードされなくなります。
このプロパティによって、必要以上に読み込みと保存が行われなくなります。
コンポーネントをコピー&ペーストすると、コピー先のジオメトリとコピー元のジオメトリは同じインスタンスになります。
[モデリング]タブでジオメトリをクリックすると、選択したフィーチャと同じインスタンスのフィーチャがハイライトされます。
この挙動は仕様で、消費するメモリを減らすことに役立っています。
このインスタンスについての機能を説明します。
3Dワールド上のジオメトリを右クリックして、ツールを開きます。
[コンポーネント一意にする]は、選択しているフィーチャのインスタンスの共有を解除します。
[自動シェア]は、選択しているフィーチャと、類似したコンポーネントのジオメトリのインスタンスを共有します。
モデルの注意点の説明は、以上になります。
次に、シミュレーションの動作を実装する時の注意点について説明します。
シミュレーションの動作に関する実装は、シミュレーション全体のパフォーマンスに関わる最も重要な部分です。
正しく実装し、必要な部分のみシミュレーションするようにすることが、シミュレーションのパフォーマンスを最高にすることにつながります。
シミュレーションの動作を実装する上で、考慮すべき点を2点紹介します。
1つ目は、作成する目的を再確認し、不要なものは削除し、追加しないようにすることです。
目的に関係ない部分の実装は行わないようにしてください。
例えば、人のアニメーションを精巧にする、シミュレーション中には見えない機械内部を細かく表現する、などがあげられます。
これらの実装は、シミュレーションのパフォーマンスを悪くします。
2つ目は、1つでたくさんの機能を兼ね備えた、汎用性の高いコンポーネントを作らないことです。
汎用性の高いコンポーネントを作ること自体は素晴らしいことですが、そのようなコンポーネントを、シミュレーションのパフォーマンスを落とさないように作成することが困難だからです。
eカタログに登録されているコンポーネントは、ある程度汎用的に作られているため、その汎用性のためにシミュレーションのパフォーマンスが少し落ちている場合があります。
eカタログのコンポーネントを使う代わりに、必要な機能のみを実装した、よりシンプルなコンポーネントを作成して使用することも検討してください。
シミュレーションの動作を実装する上で、考慮すべき点の紹介は、以上になります。
次に、シミュレーションのパフォーマンスに影響を与える、[コンポーネントプロパティ]の機能について説明します。
[モデリング]タブに移動した状態で、コンポーネントをクリックし、コンポーネントグラフ"-"プロパティ"を展開してプロパティ名をクリックし、[プロパティ]ウィンドウを開くことで設定できます。
"再構築"は、このプロパティ値が変更した時、ジオメトリを再評価・再生成する機能です。
トランスフォームフィーチャを更新する場合に必要になります。
"シミュレーションを更新"は、3Dワールドを更新してプロパティ値に基づき、コンポーネントの現在の状態を表示する機能です。
リンクの位置を更新する場合に必要になります。
シミュレーション中に頻繁に更新されるプロパティにおいて、これらの機能が有効だと、頻繁に実行されるため、シミュレーションのパフォーマンスが悪くなります。
コンポーネントプロパティを追加する場合、シミュレーション中に"再構築"や"シミュレーションの更新"が必要ないように設計してください。
シミュレーションの動作を実装する時の注意点の説明は、以上になります。
次に、モデル設計におけるベストプラクティスについて説明します。
1つ目は、「設計段階で、必要なプロパティ、機能、ビヘイビアは全て作成しておくこと」です。
シミュレーション中に、スクリプトなどを使って設定を動的に作成すると、シミュレーションのパフォーマンスが悪くなります。
必要な設定は、シミュレーション前にあらかじめ実装しておきましょう。
2つ目は、「数式のエラーは修正しておくこと」です。
ジオメトリフィーチャツリーやコンポーネントリンクツリーには、複雑な数式を定義している場合があります。
正しく定義している場合はパフォーマンスのボトルネックにはなりません。
エラーがある場合は、エラーが発生するたび数式の再評価と[出力]ウィンドウにエラーメッセージの出力が行われるため、パフォーマンスが悪くなります。
3つ目は、「できるだけパイソンスクリプトは追加せず、既存の機能だけで実装すること」です。
パイソンスクリプトを実行するには、コンテキストスイッチを使う必要があり、切り替えが発生します。
パイソンスクリプトを使用する場合、既存の設定だけで実装したモデルに比べ、切り替えが発生する分シミュレーションのパフォーマンスが悪くなります。
可能であれば、パイソンスクリプトを追加せず実装してください。
ロボットや作業者の動きを実装する場合は、パイソンスクリプトではなく、プロセスモデリングで実装する方が望ましいです。
4つ目は、「インバースキネマティクスのロボットでは、直線補間より各軸補間を使うようにすること」です。
各軸補間の方が、直線補間より計算の必要が少ないからです。
5つ目は、「可能であれば、レイキャストセンサーやボリュームセンサーを使う場合は、代わりにパスセンサーなどを使用すること」です。
レイキャストセンサーやボリュームセンサーのような「時間ごとに検出するセンサー」よりも、パスセンサーのような「シグナルを受信したら検出するセンサー」の方が、シミュレーションのパフォーマンスはよくなります。
レイキャストセンサーやボリュームセンサーを使う場合は、必要以上に検出しないように[サンプル時間]を可能な限り長く設定したり、検出対象を限定する[検出コンテナ]を設定してください。
6つ目は、「コンベアの[Accumulate]、"SpaceUtilization"、"RetainOffset"は必要ない場合は使用しないこと」です。
"Accumulate"、"SpaceUtilization"、"RetainOffset"は[コンポーネントプロパティ]ウィンドウ-[Advanced]タブから設定できます。
"Accumulate"は、先頭の製品がコンベアの端で待機している時の他の製品の動きの設定です。
チェックが入っている場合は、先頭の製品がコンベアの端で待機していても、他の製品は移動します。
チェックが入っていない場合は、先頭の製品がコンベアの端で待機している場合、他の製品はその場で停止します。
先頭の製品が移動して待機中の製品がなくなったら、他の製品も再度移動します。
"SpaceUtilization"は、製品が流れる際に、前の製品と重ならないよう、製品間で間隔をあけるようにする設定です。
チェックが入っていない場合は、製品同士で重なるようになります。
"RetainOffset"は、製品がコンベアに搬入した時に、オフセットや向きをそのまま引き継ぐ設定です。
チェックが入っていない場合は、向きを固定して中央を流れます。
この3つの設定は、製品によって処理が異なります。
そのため、有効の場合は、無効の場合よりも処理が多くなり、シミュレーションのパフォーマンスが悪くなります。
モデル設計におけるベストプラクティスの説明は、以上になります。
次に、パイソンスクリプトの実装上での注意点を説明します。
1つ目は、「メソッドで取得した値を使う場合、その都度メソッドで取得するのではなく、メソッドで取得した値を変数に格納して、値が格納された変数を使用するようにすること」です。
値を使うたびにメソッドで取得した場合、その取得する動作分シミュレーションのパフォーマンスが悪くなります。
2つ目は、「高頻度で実行する実装は、イベントで実装すること」です。
高頻度で実行する実装は、実行箇所に直接処理を記述するよりも、実行箇所から分けてイベントで実装した方が、シミュレーションのパフォーマンスはよくなります。
3つ目は、「デバッグなどで使用したPrint文などは残さないこと」です。
デバッグで使用して、実際のシミュレーションには関係ない実装は、レイアウト完成後に削除してください。
4つ目は、「rebuild関数を必要としない設計にすること」です。
rebuild関数は、再構築を行う関数です。
前述したとおり、再構築はシミュレーションのパフォーマンスが悪くなるので、再構築は使用しない、または別の方法で実装してください。
例えば、コンポーネントの色を変える関数として、vcComponent.MaterialとvcNode.NodeMaterialがあります。
vcComponent.Materialには、ジオメトリを再構築する処理が含まれています。
そのため、同じコンポーネントの色を変える関数でも、vcNode.NodeMaterialを使用することを推奨しています。
5つ目は、「シミュレーション中に特定のジオメトリの表示/非表示を切り替える場合、vcNode.Visibleを使うこと」です。
シミュレーション中にジオメトリの表示/非表示を切り替える方法として、"スイッチ"フィーチャがあります。
しかし、"スイッチ"フィーチャにも処理の中にジオメトリを再構築する処理が含まれています。
シミュレーション中に、ジオメトリの表示/非表示を切り替える場合は、vcNode.Visibleを使用することを推奨しています。
6つ目は、「更新する場合は、必要な部分のみを更新すること」です。
たとえば、vcNode.PositionMatrixを使用してノードを再配置するには、新しいマトリックス値を設定した後にノードを更新する必要があります。
この場合、全体を更新するvcSimulation.update()ではなく、vcNode.update()を使って、更新が必要なノードのみを更新するようにしてください。
パイソンスクリプトの注意点の説明は、以上になります。
シミュレーション再生の設定の注意点について説明します。
シミュレーション再生の設定は、コントロールパネルから変更できます。
[シミュレーションモード]は、[リアルタイム]と[バーチャルタイム]の二種類あります。
[リアルタイム]は、シミュレーションの速度を、実際の時間準拠にする設定です。
[バーチャルタイム]は、シミュレーションの速度を、コンピュータの性能に準拠して可能な限り速くする設定です。
[リアルタイム]は、コンピュータの時計と同期をとるので、より現実に近い状態でシミュレーションすることができます。
[バーチャルタイム]は、同期を取る必要がない分、[リアルタイム]より少し速くシミュレーションすることができます。
目的に応じて設定してください。
シミュレーションの再生速度を速くしている場合、レンダリングの頻度は低くなります。
この場合でも、シンプルな"レンダリングモード"を使用した方が、パフォーマンスはよくなります。
[シミュレーションレベル]は、コンポーネントの動きをシミュレートする時の精度の設定です。
[シミュレーションレベル]は、[コントロールパネル]と各コンポーネントのコンポーネントプロパティで設定できます。
[コントロールパネル]の[シミュレーションレベル]は、レイアウト全体に設定します。
レイアウト上に[シミュレーションレベル]を使用するコンポーネントがないと変更できません。
[既定]は、コンポーネントに定義した[シミュレーションレベル]に基づきます。
[詳細]は、コンポーネントの動きを可能な限り正確にシミュレートします。
[バランス]は、シミュレーションのパフォーマンスとバランスが取れる方法でコンポーネントの動きをシミュレートします。
例えば、ロボットジョイントの不要な動きは省略されるようになります。
[高速]は、コンポーネントの動きを高速でシミュレートします。他の設定と比べ、動きの精度は落ちますが、シミュレーションパフォーマンスはよくなります。
シミュレーション再生の設定の注意点の説明は、以上になります。
次に、シミュレーション中の機能の注意点について説明します。
まず、[リミットで停止]機能の注意点について説明します。
[リミットで停止]は、ロボットなどのジョイントが限界値を超えないか確認することができる機能です。
[プログラム]タブ-[リミット]で、有効/無効を切り替えることができます。
この機能は、ロボット単体ではなく、Gemini上のすべてのコンポーネントに適用されます。
そのため、[リミットで停止]は可能であれば無効にしてください。
最後に、[統計情報]機能の注意点について説明します。
[統計情報]機能は、シミュレーション中の値の変動をダッシュボードなどで出力する機能です。
[統計情報]機能を使う時は、[間隔]を設定します。
[間隔]は、ダッシュボードに値を表示する際に、次の値を更新するまでの間隔の設定です。
この値が小さいと、統計情報を取得する頻度が多くなり、シミュレーションのパフォーマンスが悪くなります。
シミュレーションの実行時間が長い場合などは、[統計情報]の[間隔]は大きくしてください。
シミュレーション中の機能の注意点の説明は、以上になります。
以上で、「シミュレーションの性能を最適化しよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

シミュレーション中に製品を追加してみよう（1/3）

シミュレーション中にコンポーネントを作成できる基本的なフィーダー（Feeder）をモデル化する方法
https://youtu.be/GWLs9TF3-oQ
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_001_p1.zip

シミュレーション中に製品を追加できる基本的なフィーダーをモデル化する方法を学びます。
今回は、ComponentContainerの作成と、独自のフィーダーの、基本の作成方法を紹介します。
リボンの[モデリング]タブに移動します。
コンポーネント、新規をクリックします。
3Dワールド上に、中身が何もないコンポーネントが1つ作成されます。
[コンポーネントプロパティ]ウィンドウの[名前]を、適切な名前に変更します。
今回は「Feeder」に変更します。
フィーダーの見た目にするフィーチャ を追加します。
リボンの[ジオメトリ]、[フィーチャ ]、[ボックス]をクリックします。
ボックスは「ブロック」という名前で追加されます。
フィーチャプロパティ ウィンドウでフィーダーのサイズを設定します。
長さ500mm、幅400mm、高さ700mmにします。ボックスのサイズが変更できます。
次に、このフィーダーから別のコンポーネントを作成する部分を作っていきます。
Feederを選択した状態で、ビヘイビア、コンポーネントクリエイターをクリックします。
左のコンポーネントグラフウィンドウに、ComponentCreatorが追加されます。
ComponentCreatorが作り出すコンポーネントを、[プロパティ]ウィンドウのパーツで指定します。
今回は、eカタログにある部品をフィーダーで作り出します。
[ホーム]タブ-[eカタログ]-[タイプ別モデル]-[Products and Containers]-[Visual Components]-[Car Tyre]を右クリックして、[メタデータを表示]をクリックします。
eカタログに登録されている部品のメタデータが表示されます。
メタデータのVCIDをコピーします。
コピーできたら閉じます。
[モデリング]タブに戻ります。
[コンポーネントグラフ]ウィンドウ-[Feeder]-[ビヘイビア]-[ComponentCreator]をクリックします。
[プロパティ]ウィンドウ-[パーツ]に「vcid:」を入力し、その後ろにさきほどコピーしたVCIDをペーストします。
このフィーダーから、さきほどのタイヤの部品を生成できるようになります。
シミュレーションを実行します。
まだ3Dワールド上には何も生成されない状態です。
動的に作成されたコンポーネントは、3Dワールド上の何かにくっついていたり、含まれていたりしなければなりません。
そうでない場合、メモリーを節約するために消えてしまいます。
[コンポーネントグラフ]ウィンドウでFeederを選択し、[モデリング]タブ、ビヘイビア、コンテナをクリックします。
コンポーネントグラフウィンドウにComponentContainerが追加されます。
[コンポーネントグラフ]ウィンドウのComponentCreatorとComponentContainerを展開すると、InputとOutputがあります。
それぞれのビヘイビアに対して、ものが入ってくるところと出ていくところを、設定するところです。
ComponentCreatorで作成したものをComponentContainerに持たせたいため、[コンポーネントグラフ]ウィンドウ、ComponentCreator、Outputをクリックします。
[プロパティ]ウィンドウ、接続を、ComponentContainerに設定します。
ComponentCreatorで作成したものをComponentContainerに対してアウトプットする設定をすることで、シミュレーションを再生すると、ComponentCreatorで設定したパーツのコンポーネントが、3Dワールド上に生成されます。
シミュレーションをリセットします。
シミュレーションを再生すると、フィーダーの下の部分にコンポーネントが生成されます。
どこにコンポーネントを生成するか位置を決めていきます。
[コンポーネントグラフ]ウィンドウのFeederを選択して、ジオメトリ、フィーチャ、フレームをクリックします。
ボックスの上の面にコンポーネントを作成したいため、[コンポーネントグラフ]ウィンドウの下側に表示されたフレームを、モデリング、ツール、スナップを選択して、上面中央に設定します。
[コンポーネントグラフ]ウィンドウ、ComponentContainerをクリックします。
[プロパティ]ウィンドウ、位置にフレームを選択後、シミュレーションを再生すると、さきほど指定したフレームの位置にコンポーネントが生成されます。
3Dワールド上に、別のコンポーネントを作成できるようになりました。
実際使う際は、コンベアが繋がっていて、そこにコンポーネントを流していきます。
作成したコンポーネントが、別のものに流れる設定を、追加していきます。
[コンポーネントグラフ]ウィンドウのFeederを選択して、ビヘイビア、ワンウェイパスをクリックします。
ワンウェイパスはコンポーネントが流れる方向を設定します。
一方向にだけコンポーネントが流れる設定をする際に使います。
Feederにもう一つフレームを追加します。
ジオメトリ、フィーチャ 、フレームをクリックします。
作成されたフレームアンダーバー1を選択して、ツール、スナップを選択して、ボックスの上面右側に配置します。
[コンポーネントグラフ]ウィンドウのFeeder、ビヘイビア、OneWayPathをクリックします。
フレームからフレームアンダーバー1にコンポーネントが流れてほしいため、[プロパティ]ウィンドウ、パス、矢印、「＋」をクリックし、フレーム、フレームアンダーバー1の順番で追加します。
[コンポーネントグラフ]ウィンドウ、OneWayPathhをクリックすると、InputとOutputがあります。
OneWayPathに対してコンポーネントが入ってくるInputの設定をします。
OneWayPathに、ComponentCreatorが作成したコンポーネントを流す設定にします。
[コンポーネントグラフ]ウィンドウ、OneWayPath、Inputをクリックします。
[プロパティ]ウィンドウ、接続に、ComponentCreatorを選択します。
[プロパティ]ウィンドウ、ポートに、Outputを選択します。
ComponentCreatorのOutputにOneWayPathのInputがくっつくイメージです。
シミュレーションを再生すると、設定したパスの通りにコンポーネントが流れることを確認できます。
Feederの真ん中から端までコンポーネントを流す設定ができました。
コンベアと接続する設定を追加します。
ビヘイビア、1対1接続をクリックします。
OneToOneInterfaceが追加されます。
[プロパティ]ウィンドウ、[新規セクションを追加]をクリックします。
セクションフレームは、コンベアとの接続点をどこにするかの設定です。
セクションフレームに、フレームアンダーバー1を設定します。
フィールドは、コンポーネントが流れるフィールドにするため、[新規フィールドを追加]で、Flowを追加します。
Containerに、ボックス上部をコンポーネントが流れる、OneWayPathを選択します。
PortNameに、OneWayPathの続きがどこに繋がっていくかを設定するため、Outputを選択します。
Feederの設定は完了しました。
[ホーム]タブに戻ってフィーダーを選択すると、PnPで接続する箇所を表す、黄色い三角形が表示されています。
[eカタログ]-[タイプ別モデル]-[Conveyors]-[Visual Components]-[Conveyor]を3Dワールドにドラッグアンドドロップします。
PnPを選択した状態で、配置したコンベアをフィーダーに近づけて、繋げます。三角形が緑になります。
シミュレーションを再生すると、生成されたコンポーネントがコンベアに乗って移動します。
自分で作成したものを、他のプロジェクトで再利用したい場合、eカタログに登録することができます。
3Dワールドのフィーダーを選択します。
[モデリング]タブ-[コンポーネント]-[保存]をクリックします。
コンポーネントを保存するプロパティが表示されます。
コンポーネントを保存、保存をクリックします。
保存するダイアログを表示します。
C、ユーザー、パブリック、パブリックのドキュメント、MITSUBISHI、Gemini、バージョン、My Modelsに保存します。
[ホーム]タブ-[eカタログ]の[マイモデル]で保存したコンポーネントが表示されます。
eカタログと同じように使えるようになります。
フィーダーに、別のコンポーネントを流したい場合、パーツのVCIDに別のeカタログを貼り付けることで、変更できます。
[ホーム]タブに移動します。
[eカタログ]-タイプ別モデル]-[Products and Containers]-[Visual Components]-[Ball]を右クリックして、メタデータ内のVCIDをコピーします。
[モデリング]タブに戻ります。
フィーダーの[コンポーネントグラフ]ウィンドウのComponentCreatorを選択します。
[プロパティ]ウィンドウ、パーツの情報を削除して、「vcid:」を入力後、コピーしたVCIDをペーストして、エンターキーを押下します。
シミュレーショ実行すると、指定したコンポーネントが流れます。
以上で「シミュレーション中に製品を追加してみよう、パート1」の説明を終わります。
ご視聴ありがとうございました。

=================================================================================

シリンダーを作ってみよう(1/3)

https://youtu.be/V8CWnzSqr_w
オリジナルのシリンダーを作成する方法
（3DCADファイルをインポート、機構付け）
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_088_p1.zip

オリジナルのシリンダーを作成する方法を説明します。
オリジナルのシリンダーが完成すると、ワークをコンベアへ押し出すことができます。
コンベアが配置してあるファイル[Cylinder_before.vcmx]が必要です。
本動画では、シリンダーをインポートし、可動部を設定します。
シリンダーのCADファイルをインポートします。
[ホーム]タブをクリックし、[インポート]グループの[ジオメトリ]をクリックすることで、CADファイルをインポートできます。
[Cylinder.3ds]を選択し、[開く]をクリックします。
[モデルをインポート]ウィンドウでは、インポート時のプロパティを設定できます。
[構造]は、単一のモデルをインポートする場合、[フィーチャ]か[ノード]を選択します。
レイアウトをインポートする場合、[コンポーネント]を選択します。
[Cylinder.3ds]を、単一のモデルとしてインポートし、可動部を設定するため、[フィーチャ]を選択します。
3Dワールドに表示されるモデルは、多数の三角形で構成されており、[テッセレーションの品質]は、三角形の個数を設定できます。
データ量の多いモデルの場合、低品質にすることで、データ量を削減できます。
今回はデータ量が少ないため、[中位品質]に設定します。
[含める]では、インポートするとき、ジオメトリに含む要素を設定できます。
今回は、[マークアップ]と[マテリアル]と[テクスチャー]を選択します。
[マテリアル作成ルール]では、マテリアルライブラリを作成するためのルールを設定できます。
今回は、[常にライブラリから最も近似のものを使用します]を選択します。
[フィーチャツリー]は、フィーチャツリーの作成方法を、設定できます。
[完全]は、CADファイルの階層構造をベースにし、すべてのジオメトリをトランスフォームフィーチャに入れ、フィーチャツリーを作成します。
CADファイルと完全に階層構造を一致させる場合、[完全]を選択します。
[最適化]は、すべてのジオメトリを同じ階層にし、[最小化]は、ジオメトリを1つにまとめることができます。
シリンダーの可動部を設定するとき、フィーチャツリーをシンプルにするため、[最適化]を選択します。
[ジオメトリを整理]では、ジオメトリセットを作成するルールを設定できます。
ジオメトリセットは、フィーチャツリーの各ジオメトリの中に含まれるジオメトリのまとまりです。
メッシュを構成する三角ポリゴンの3点の合計が10000を超えると、新しいジオメトリセットが作成されます。
面ごとにジオメトリセットを作成する場合、[面による]を選択し、マテリアルごとは、[マテリアルによる]を選択します。
ジオメトリセットを1つにまとめる場合、[折りたたみ]を選択し、曲線のジオメトリセットは、[数学的データ]を選択します。
今回は、[マテリアルによる]を選択します。
[上軸]は、ジオメトリの上面と底面を整列させる軸を設定できます。
[上軸]で[-X]を選択し、[インポート]をクリックします。
シリンダーのCADファイルをインポートできます。
シリンダーが、3Dワールドの原点にインポートされない場合、[コンポーネントプロパティ]ウィンドウの座標をすべて0に変更します。
シリンダーの可動部を設定するため、[モデリング]タブを開きます。
シリンダーの青い部分をすべて選択します。
コントロールキーを押した状態で、選択をすることで、複数のジオメトリを選択できます。
右クリックして、メニューを開きます。
[抽出]から[抽出リンク]を選択することで、選択したジオメトリを新しいノードに抽出できます。
[コンポーネントグラフ]ウィンドウに、「Link_1」が追加されたことがわかります。
Link_1に動作の詳細を設定します。
[リンクプロパティ]ウィンドウで[JointType]を設定することで、動作の種類を定義できます。
固定は、動作は設定せず、ノードを定義した位置に固定できます。
回転は、定義した軸を中心に回転運動、直進は、軸に沿って直線運動をします。
回転フォロワーは、別のノードの運動量に基づき、定義した軸を中心に回転運動、変換フォロワーは、直線運動することができます。
カスタムは、定義した軸を基準に、回転運動か直線運動することができます。
今回は、直進を選択します。
可動部が動作する方向を設定します。
[軸]で+Xを選択します。
可動部が動作する方向を確認します。
[マニピュレーション]グループの[インタラクティブ]を選択することで、可動部の動作を確認できます。
3Dワールドで「Link_1」をドラッグします。
「Link_1」が、X軸方向に動作することがわかります。
シミュレーションのリセットボタンをクリックすることで、可動部が初期位置に戻ります。
[リンクプロパティ]ウィンドウの[Controller]は、ノードの動作を制御するコントローラーを定義できます。
[Controller]をクリックし、「新規サーボコントローラ」を選択します。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]を展開すると、サーボコントローラが追加されたことがわかります。
Geminiのサーボコントローラは、一般的なサーボコントローラとは異なり、可動部を制御する仮想のコントローラーです。
[リンクプロパティ]ウィンドウの[初期値]はノードの初期位置、[J1]はノードの現在位置を表示しています。
現在、[初期値]と[J1]は0です。
[最小リミット]と[最大リミット]は、ノードが動作できる範囲の最小値と最大値を定義できます。
[最小リミット]を0、[最大リミット]を250に設定します。
3Dワールドで「Link_1」をドラッグします。
「Link_1」が、[最小リミット]と[最大リミット]の範囲外に動作すると、[リンクプロパティ]ウィンドウの[J1]にエラーが発生します。
範囲外に動作しない設定にする場合、[プログラム]タブをクリックし、[リミット]グループの[リミットで停止]にチェックを付けます。
[モデリング]タブをクリックします。
3Dワールドで、「Link_1」をドラッグします。
範囲外に動作しないことを確認します。
リセットボタンをクリックします。
シリンダーの可動部を設定する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

シリンダーを作ってみよう(2/3)

オリジナルのシリンダーを作成する方法
（ウィザードのアクションスクリプト、つかむ検出範囲、リリース距離、動作のプログラム）
https://youtu.be/HiSCSfS-UMk
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_088_p2.zip

シリンダーで、ワークを押し出すために必要な設定について説明します。
本動画は、シリンダーの可動部を設定する方法の続きから設定します。
シリンダーの可動部の設定が、完了しているファイル[Cylinder1_after.vcmx]が必要です。
シリンダーに、ワークを押し出すために必要な設定を追加します。
シリンダーを選択します。
[コンポーネントグラフ]ウィンドウで、Cylinderを選択します。
[追加]グループの[ウィザード]を展開し、[コンポーネントウィザード]から[アクションスクリプト]を選択します。
アクションスクリプトは、特定のアクションをシグナルで制御するために必要な設定を、選択したコンポーネントに、自動的に追加する機能です。
[出力]ウィンドウには、KinematicsはControllerに関連付けられていることを示すメッセージが表示されます。
[コンポーネントグラフ]ウィンドウに、設定が追加されたことがわかります。
[プロパティ]に追加された設定は、[コンポーネントプロパティ]ウィンドウの[シグナルアクション]タブを表示するための設定です。
[シグナルアクション]タブでは、アクションを実行するときの設定を変更できます。
[ビヘイビア]のStatisticsは、統計情報を収集、報告する設定です。
Executorは、[プログラム]タブでロボットプログラムを作成し、実行するために必要な設定です。
Inputs、Outputsは、連続した番号のシグナルです。
Controllerは、シリンダーの内部構造を定義しています。
Kinematicsは、シリンダーが動作するために必要な、ノードの運動量を計算する設定です。
ActionScriptは、アクションをシグナルで制御し、実行するときの設定を[シグナルアクション]タブで変更するためのプログラムが記述されています。
Actionsは、アクションを保存しておくための設定です。
Link_1には、新しくmountplateが追加され、GraspContainerという名前のコンポーネントコンテナがあります。
コンテナは、コンポーネントに、別のコンポーネントを格納できます。
別のコンポーネントをコンテナに格納、解放するアクションがあります。
シリンダーに、アクションの基準点を設定します。
[コンポーネントグラフ]ウィンドウの[Controller]と、[ツール]を展開します。
TOOL_1から16という名前のツールフレームがあります。
ツールフレームがない場合、一度3Dワールドの何もない空間をクリックし、シリンダーの選択を解除します。
再度、シリンダーを選択することで、[コンポーネントグラフ]ウィンドウに、ツールフレームが現れます。
3Dワールドに、ツールフレームが表示されない場合、3Dワールドツールバーのフレームタイプを開き、ロボットツールにチェックを付けます。
3Dワールドに、ツールフレームを表示できます。
ツールフレームを移動させるため、[コンポーネントグラフ]ウィンドウのTOOL_1を選択します。
[ツール]グループの[スナップ]を選択し、3Dワールドで目的の位置をクリックすることで、位置を変更できます。
シリンダーの青い面の中心をクリックします。
シグナルで制御されたアクションを設定します。
[コンポーネントグラフ]ウィンドウで、Cylinderを選択します。
[コンポーネントプロパティ]ウィンドウの[アクション設定]を展開します。
シグナルアクションは、シグナルがTrueの時と、Falseの時に、アクションを設定できます。
[シグナルアクション]の[出力]で、シグナル番号を指定します。
アクションスクリプトを使用した場合、[出力]1から64には、アクションがすでに設定されています。
今回は、設定済みのシグナルアクションを編集します。
[出力]をクリックし、1を選択します。
[オントゥルー]につかむ、[オンフォルス]にリリースが設定されています。
[出力]1がTrueのとき、コンポーネントをコンテナに格納し、Falseのとき、コンテナから解放できます。
格納するときの、コンポーネントを検出する範囲を設定します。
[つかむ]の[使用ツール]は、検出範囲の中心を定義するツールフレーム、[DetectionVolumeSize]は、検出範囲のサイズです。
シリンダーの青い面でワークを押し出します。
TOOL_1を中心とするため、[使用ツール]は変更しません。
[DetectionVolumeSize]の[X]を90、[Y]を130、[Z]を40に変更します。
解放するときの、コンポーネントの置き場所を検出する範囲を設定します。
[リリース]の[GravityDirection]は、格納しているコンポーネントの底面からの距離です。
底面から[GravityDirection]までの範囲内にある、パスやコンテナに、コンポーネントを格納できます。
範囲内にパスやコンテナがない場合、3Dワールドにコンポーネントを解放します。
今回は、10に変更します。
コンポーネントを検出する範囲を表示する場合、[シグナルアクション]タブの[検出容積を表示]にチェックを付けます。
現在、シリンダーには接続設定がないため、[出力]ウィンドウにエラーメッセージが表示されます。
表示する検出範囲の位置を変更するためのプログラムを、実行することができません。
[コンポーネントプロパティ]ウィンドウで、[検出容積を表示]からチェックを外します。
シリンダーに接続設定を追加します。
[コンポーネントグラフ]ウィンドウで、mountplateを選択します。
[動作設定]グループの[ビヘイビア]を展開し、[インターフェース]から[1対1接続]を選択します。
1対1接続は、1対1接続、または1対多接続が設定された別のコンポーネントと接続することができます。
今回は、別のコンポーネントと接続しないため、詳細は設定しません。
[コンポーネントグラフ]ウィンドウで、Cylinderを選択します。
[コンポーネントプロパティ]ウィンドウの[シグナルアクション]で、[検出容積を表示]にチェックを付けます。
検出範囲は、3Dワールドに半透明な直方体で表示されます。
検出範囲の表示方法を変更する場合、[検出容積ジオメトリー]を変更します。
[検出容積ジオメトリー]をLineに変更すると、検出範囲は赤い枠で表示されます。
[検出容積ツール]と[検出容積サイズ]を、[アクション設定]の[つかむ]と一致させることで、コンポーネントを検出する範囲を表示できます。
[検出容積サイズ]の[X]を90、[Y]を130、[Z]を40に変更します。
[検出容積を表示]からチェックを外し、検出範囲を非表示にします。
シリンダーのシグナルを制御し、シグナルアクションのつかむ、リリースを実行します。
[プログラム]タブをクリックします。
[プログラムエディタ]ウィンドウの[サブプログラム]には、プログラムが設定されていないメインルーチンが表示されています。
シミュレーションを実行すると、メインルーチンのプログラムを上から実行できます。
今回は、サブルーチンを追加し、PythonScriptでサブルーチンを呼び出すことで、動作を実行します。
PythonScriptの設定は、次の動画で説明します。
ワークをコンテナに格納するサブルーチンを作成します。
[サブプログラム]の[シーケンスを追加]をクリックすることで、サブルーチンが追加されます。
[サブプログラム]に、Sequence1が追加されたことがわかります。
[ルーチンプロパティ]ウィンドウで、[名前]をGrabに変更します。
ステートメントツールバーから、[セットバイナリ出力ステートメント]を選択します。
セットバイナリ出力ステートメントは、シグナル番号を指定し、シグナルの値を送信できます。
シグナル1をTrueにすることで、ワークを格納します。
[ステートメントプロパティ]ウィンドウの[バイナリ出力ステートメント]を1に設定します。
[出力値]にチェックを付け、値をTrueに変更します。
シグナルを送信する前後に遅延を発生させ、処理の時間に猶予を持たせます。
[プログラムエディタ]ウィンドウの、ステートメントツールバーから、[遅延ステートメント]を選択します。
遅延ステートメントは、指定した秒数の遅延を発生させます。
[ステートメントプロパティ]ウィンドウで、[遅延]を1に変更します。
シリンダーは、シグナル送信後、1秒待機させます。
[プログラムエディタ]ウィンドウで、Delay 1sを選択します。
コピーして貼り付けます。
2つ目のDelay 1sをドラッグ＆ドロップで、Set OUT[1]の上に移動します。
Grabをコピーし、編集することで、ワークを開放するサブルーチンを作成します。
Grabを選択します。
[サブプログラム]の[シーケンスをコピー]をクリックすることで、サブルーチンをコピーできます。
[サブプログラム]に、Grab1が追加されたことがわかります。
[ルーチンプロパティ]ウィンドウで、[名前]をReleaseに変更します。
[プログラムエディタ]ウィンドウで、Set OUT[1]を選択します。
シグナル1をFalseにすることで、ワークを開放します。
[ステートメントプロパティ]ウィンドウの[出力値]からチェックを外し、値をFalseに変更します。
シリンダーで、ワークを押し出すために必要な設定についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

シリンダーを作ってみよう(3/3)

オリジナルのシリンダーを作成する方法
（動作のプログラムを制御するPythonスクリプト）
https://youtu.be/k1FqS6fdd6k
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_088_p3.zip

シリンダーで、ワークを押し出すとき、パイソンスクリプトで制御する方法について説明します。
本動画は、シリンダーでワークを押し出すために必要な設定の続きから設定します。
シリンダーでワークを押し出すために必要な設定が、完了しているファイル[Cylinder2_after.vcmx]が必要です。
シリンダーが動作するタイミングを指示するため、シグナルを追加します。
[モデリング]タブをクリックします。
[コンポーネントグラフ]ウィンドウで、Cylinderを選択します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[ブール型]を選択します。
ブール型シグナルは、オンオフを送受信できます。
名前をPullに変更します。
同様に、ブール型シグナルを1つ追加します。
名前は、Pushです。
Pullがオンのとき、「Link_1」は0の位置、Pushがオンのとき、「Link_1」は250の位置に移動させます。
シリンダーの動作完了を通知するため、プロパティを追加します。
[プロパティ]グループの[プロパティ]を展開し、[ベーシック]から[ブール型]を選択します。
プロパティは、コンポーネントのグローバル変数であり、シリンダーのサブプログラムのどのシーケンスからでも使用できます。
名前をX1に変更します。
同様に、ブール型プロパティを1つ追加します。
名前は、X2です。
X1はPullの動作、X2はPushの動作が完了したとき、オンにします。
本動画では、X1とX2の各状態を判別し、使用することはありません。
PLCと連携し、ラダー回路でシリンダーの動作を制御するときに使用するため、参考としてX1とX2を追加しています。
シリンダーにワークを押し出すためのパイソンスクリプトを追加します。
[コンポーネントグラフ]ウィンドウで、「Link_1」を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
エディタが自動的に開くため、デフォルトで記述されているソースコードを1行目以外削除します。
ロボットプログラムのサブルーチンを実行するため、ロボット関数をインポートします。
[プログラム]タブで作成したプログラムを、ロボットプログラムといいます。
from vcHelpers.Robot2 importと記述します。
パイソンスクリプトを含むコンポーネントの情報を取得するため、comp=getComponent()と記述します。
servo=comp.findBehaviourと記述することで、コンポーネントのビヘイビアを参照できます。
カッコ内にサーボコントローラと記述し、名前を指定します。
シグナルを参照するため、pull=comp.findBehaviour("Pull")と記述します。
同様に、ビヘイビアのPushを参照します。
変数名は、pushです。
X1a=comp.getPropertyと記述することで、コンポーネントのプロパティを参照できます。
カッコ内にX1と記述し、名前を指定します。
同様に、プロパティのX2を参照します。
変数名は、X2aです。
def OnRun():と記述することで、シミュレーション開始時にプログラムを実行できます。
サブルーチンを呼び出すため、ロボットプログラムの情報を取得します。
robot=getRobotと記述します。
シリンダーの初期状態と、プロパティの値を一致させるため、プロパティに初期値を設定します。
[コンポーネントグラフ]ウィンドウのX1とX2は、シリンダーの「Link_1」の状態を示します。
X1は、「Link_1」が0の位置にある状態です。
X2は、「Link_1」が250の位置にある状態です。
シミュレーション開始時、「Link_1」は0の位置にあるため、X1aをTrue、X2aをFalseに設定します。
while True:と記述し、以下のプログラムをループさせます。
triggerCondition(lambda:getTrigger()==pull or getTrigger()==push)と記述することで、pullかpushのオンオフが切り替わるまで、以下のプログラムを実行せず、待機できます。
pullがTrueの場合、「Link_1」を0の位置に移動します。
X2a.Value=Falseと記述し、「Link_1」が250の位置にあることを示すX2をオフにします。
「Link_1」を0の位置に移動するため、servo.moveJoint(0,0)と記述します。
moveJointは、サーボコントローラで制御されたノードを、移動させることができます。
カッコ内の最初の0は、サーボコントローラに定義されているノードリストの0番目を表しています。
2つ目の0は、ノードが移動する目標位置です。
X1a.Value=Trueと記述し、「Link_1」が0の位置に移動完了したことを示します。
pushがTrueの場合、「Link_1」を移動させ、ワークを押し出します。
X1a.Value=Falseと記述し、「Link_1」が0の位置にあることを示すX1をオフにします。
ワークを押し出すときのワークとシリンダーの位置関係は、ワークをコンテナに格納したときの位置で決まります。
ワークとシリンダーが接している状態で、ワークをコンテナに格納します。
「Link_1」をワークの位置に移動するため、servo.moveJoint(0,50)と記述します。
ワークをコンテナに格納するため、robot.callSubRoutineと記述します。
カッコ内にGrabと記述し、名前を指定します。
callSubRoutineは、ロボットプログラム内の、事前定義されたサブルーチンを、名前を指定して呼び出せます。
「Link_1」を250の位置に移動するため、servo.moveJoint(0,250)と記述します。
ワークをコンテナから解放するサブルーチンを呼び出します。
robot.callSubRoutine("Release")と記述します。
X2a.Value=Trueと記述し、「Link_1」が250の位置に移動完了したことを示します。
コンパイルをクリックします。
先程、PythonScriptに記述したtriggerConditionで、PullとPushをトリガーとして使用するため、接続します。
[コンポーネントグラフ]ウィンドウで、ビヘイビアのPullを選択します。
[プロパティ]ウィンドウの[接続]をクリックします。
表示されたプラスアイコンをクリックすることで、[Add Connections items]ウィンドウが表示されます。
PythonScriptを選択し、[Add Connections items]ウィンドウを閉じます。
同様に、PushとPythonScriptを接続します。
シミュレーションを実行します。
[接続]グループの[シグナル]をクリックし、シリンダーを選択することで、シグナルエディタが表示されます。
Pushをクリックしてオンにします。
シリンダーは、ワークの位置まで移動し、ワークをコンベアまで押し出します。
ワークがコンベア上を流れたため、シリンダーのコンテナから、コンベアのパスに格納されたことがわかります。
Pushをクリックしてオフにします。
Pullをクリックしてオンにします。
シリンダーは、初期位置に戻ります。
シリンダーで、ワークを押し出すとき、パイソンスクリプトで制御する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

センサーを作ってみよう

オリジナルのセンサーを作る方法
https://youtu.be/Dz0usiEr7rU
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_077.zip

オリジナルのセンサーモデルを作成する方法を説明します。
センサーを使用して、ワークの内部情報を取得する方法について説明します。
CADファイルをインポートします。
[ホーム]タブを選択し、[インポート]グループの[ジオメトリ]をクリックすることで、CADファイルをインポートすることができます。
[Sensor.3ds]を選択し、[開く]をクリックします。
[モデルをインポート]ウィンドウでは、インポート時のプロパティを設定することができます。
[構造]は、単一のモデルをインポートする場合、[フィーチャ]か[ノード]を選択します。
レイアウトをインポートする場合、[コンポーネント]を選択します。
単一のモデルをインポートし、可動部は設定しないため、[フィーチャ]を選択します。
3Dワールドに表示されるモデルは、多数の三角形で構成されており、[テッセレーションの品質]は、三角形の個数を設定することができます。
データ量の多いモデルの場合、低品質にすることで、データ量を削減することができます。
今回はデータ量が少ないため、[中位品質]に設定します。
[含める]では、インポートするとき、ジオメトリに含む要素を設定することができます。
今回は、[マークアップ]と[マテリアル]と[テクスチャー]を選択します。
[マテリアル作成ルール]では、マテリアルライブラリを作成するためのルールを設定することができます。
今回は、[常にライブラリから最も近似のものを使用します]を選択します。
[フィーチャツリー]は、フィーチャツリーの作成方法を、設定することができます。
[完全]は、CADファイルの階層構造をベースにし、すべてのジオメトリをトランスフォームフィーチャに入れ、フィーチャツリーを作成します。
CADファイルと完全に階層構造を一致させる場合、[完全]を選択します。
[最適化]は、すべてのジオメトリを同じ階層にし、[最小化]は、ジオメトリを1つにまとめることができます。
フィーチャツリーをシンプルにするため、[最適化]を選択します。
[ジオメトリを整理]では、ジオメトリセットを作成するルールを設定することができます。
ジオメトリセットは、フィーチャツリーの各ジオメトリの中に含まれるジオメトリのまとまりです。
メッシュを構成する三角ポリゴンの3点の合計が10000を超えると、新しいジオメトリセットが作成されます。
面ごとにジオメトリセットを作成する場合、[面による]を、マテリアルごとの場合、[マテリアルによる]を選択します。
ジオメトリセットを1つにまとめる場合、[折りたたみ]を、曲線のジオメトリセットを作成する場合、[数学的データ]を選択します。
今回は、[マテリアルによる]を選択します。
[上軸]は、ジオメトリの上面と底面を整列させる軸を設定することができます。
[上軸]で[-X]を選択し、[インポート]をクリックします。
センサーモデルのCADファイルをインポートすることができます。
同様に、ワークとして使用するCADファイルもインポートします。
ファイル名は、[WorkA.3ds]と[WorkB.3ds]です。
センサーで取得するワークの内部情報を設定します。
ワークAを選択し、[モデリング]タブをクリックします。
ワークAに情報を設定するため、プロパティを追加します。
プロパティは、コンポーネントのグローバル変数であり、プログラム内のどこからでも使用することができます。
[プロパティ]グループの[プロパティ]を展開します。
[ベーシック]から[文字列]を選択することで、文字列型の情報を設定することができます。
[コンポーネントグラフ]ウィンドウの[プロパティ]にString_1が追加されたことがわかります。
ワークAは、色が茶色であるため、[プロパティ]ウィンドウで[名前]をColor、[値]をBrownに変更します。
同様に、ワークBに色が赤であるという情報を設定します。
ワークBを選択します。
[プロパティ]グループの[プロパティ]を展開し、[ベーシック]から[文字列]を選択します。
[プロパティ]ウィンドウで[名前]をColor、[値]をRedに変更します。
ワークを検出するため、センサーを設定します。
今回は、シミュレーション開始前からワークを配置していますが、シミュレーション後にワークを生成する場合もあります。
ワークは、生成時にランダムな名前が付与されます。
ワークの情報を取得するため、ワークを検出するセンサーが必要です。
センサーの位置を設定します。
センサーモデルをダブルクリックすることで、コンポーネントを選択することができます。
[ジオメトリ]グループの[フィーチャ]を展開し、[その他]から[フレーム]を選択します。
フレームは、3Dワールド上で、位置と方向を定義する基準点です。
3Dワールドに、フレームが表示されない場合、3Dワールドツールバーのフレームタイプを開き、フレームにチェックを付けます。
3Dワールドにフレームを表示することができます。
フレームをセンサーモデルの円形部品の中心に移動します。
フレームを選択した状態で、[ツール]グループの[スナップ]を選択し、目的の位置をクリックすることで、フレームを移動させることができます。
センサーモデルの円形部品の中心をクリックします。
ワークを検出するため、センサーを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[センサー]から[レイキャスト]を選択します。
レイキャストセンサーは、定義したフレームの位置から光線を照射し、光線と交差したコンポーネントを検出することができます。
センサーの位置を、フレームを選択して、定義します。
[プロパティ]ウィンドウの[フレーム]をクリックし、フレームを選択することで、フレームの+Z軸方向に光線を照射することができます。
表示する光線の長さと、ワークを検出する範囲を設定します。
[最大範囲]は、3Dワールドに表示する光線の長さを設定し、[検出しきい値]は、コンポーネントを検出する範囲を設定することができます。
[最大範囲]と[検出しきい値]を300に変更します。
光線を非表示にするときは[光線表示]のチェックを外し、光線を表示するときは[光線表示]にチェックを付けます。
今回は、[光線表示]にチェックを付けます。
[コンポーネントシグナル]は、検出したコンポーネントを値として格納するシグナルを定義します。
センサーで検出したワークの情報を格納するため、シグナルを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[コンポーネント]を選択します。
コンポーネントシグナルは、コンポーネントを値として送受信することができます。
[コンポーネントグラフ]ウィンドウで、RaycastSensorを選択します。
[プロパティ]ウィンドウの、[コンポーネントシグナル]でComponentSignalを選択します。
[ブールシグナル]は、コンポーネントを検出しているかを、シグナルのオンオフで通知することができます。
センサーモデルに、ワークの検出を通知するシグナルを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[ブール型]を選択します。
[コンポーネントグラフ]ウィンドウで、RaycastSensorを選択します。
[プロパティ]ウィンドウの[ブールシグナル]で、BooleanSignalを選択します。
コンポーネントを検出したとき、BooleanSignalがオンに、検出していないとき、BooleanSignalがオフになります。
センサーモデルに、取得したワークの内部情報を格納します。
情報を格納しておくため、プロパティを設定します。
ワークの内部情報は文字列型のため、格納するセンサーのプロパティも文字列型を使用します。
[プロパティ]グループの[プロパティ]を展開し、[ベーシック]から[文字列]を選択します。
名前をInfoに変更します。
パイソンスクリプトにセンサーがワークを検出したとき、プロパティに情報を格納するプログラムを記述します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
エディタが自動的に開くため、デフォルトで記述されているソースコードを1行目以外削除します。
パイソンスクリプトを含むコンポーネントの情報を取得するため、comp = getComponent()と記述します。
info=comp.getPropertyと記述することで、コンポーネントのプロパティを参照することができます。
カッコ内にInfoと記述し、名前を指定します。
signal=comp.findBehaviourと記述することで、コンポーネントのビヘイビアを参照することができます。
カッコ内にComponentSignalと記述し、名前を指定します。
def OnRun():と記述することで、シミュレーションの開始時にプログラムを実行することができます。
while True:と記述し、以下のプログラムをループさせます。
while Trueのみでは、瞬時にプログラムが繰り返し実行されるため、処理が追い付かず、シミュレーションが進みません。
ループ中に遅延させることで、処理の時間に猶予を持たせ、シミュレーションを進めることができます。
delayと記述することで、指定した時間、遅延させることができます。
カッコ内に0.1と記述することで、0.1秒遅延させます。
if signal.Value!=Noneと記述することで、センサーがワークを検出した場合を示します。
センサーで検出したコンポーネントを、ワークとして定義するため、work=signal.Valueと記述します。
ワーク内のプロパティを参照するため、color=work.getPropertyと記述します。
参照するプロパティの名前は、Colorです。
ワークのプロパティの値を、センサーのプロパティに格納するため、info.Value=color.Valueと記述します。
elif signal.Value==Noneと記述することで、センサーがなにも検出していない場合を示します。
センサーがワークを検出していない場合、センサーのプロパティの値をリセットします。
info.Value=" "と記述することで、プロパティの値を空白にすることができます。
コンパイルをクリックします。
センサーの検出範囲にワークAを移動します。
ワークAをダブルクリックして、コンポーネントを選択します。
[ツール]グループの[スナップ]を選択し、センサー前の台の中心をクリックします。
シミュレーションを実行します。
[接続]グループの[シグナル]をクリックし、センサーモデルを選択することで、シグナルエディタを表示することができます。
センサーがワークを検出しているため、BooleanSignalはオンの状態です。
[接続]グループの[シグナル]をクリックし、シグナルエディタを非表示にします。
[コンポーネントグラフ]ウィンドウで、Infoの値がBrownであることが確認できます。
シミュレーションを一時停止します。
ワークAを台からおろし、ワークBを台の上にのせます。
シミュレーションを再度実行します。
センサーモデルをダブルクリックします。
[コンポーネントグラフ]ウィンドウで、Infoの値がRedであることが確認できます。
シミュレーションを一時停止します。
ワークBを台からおろします。
シミュレーションを再度実行します。
[接続]グループの[シグナル]をクリックし、センサーモデルを選択します。
センサーがなにも検出していないため、BooleanSignalはオフの状態です。
[コンポーネントグラフ]ウィンドウで、Infoの値が空白であることが確認できます。
センサーを使用して、ワークの内部情報を取得する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ターンコンベアを作ってみよう

オリジナルのターンコンベアを作る方法
https://youtu.be/jGhp9RduDsA
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_010.zip

回転するコンベアをモデリングする方法について説明します。
回転するコンベアは、箱を受け取り、箱が中心に達すると回転し、回転が終了すると、箱は別のコンベアに向かい流れ始めます。
最初に、モデリングしたいコンポーネントのジオメトリをインポートします。
ファイルを、3Dワールドにドラッグ＆ドロップする方法もありますが、今回は別の方法を説明します。
[ホーム]タブに移動し、[インポート]グループの[ジオメトリ]をクリックし、回転するコンベアのファイルを選択し、[開く]をクリックします。
次に、[モデルをインポート]ウィンドウで、各項目を確認し、[インポート]ボタンをクリックすると、新しいコンポーネントにジオメトリをインポートし、3Dワールドに表示することができます。
新しいコンポーネントは、3Dワールドの原点に配置されます。
コンポーネントを選択します。
コンポーネントプロパティに移動し、[名前]を確認すると、ファイル名がコンポーネント名となっています。
コンポーネントは、ワールド座標を使用しており、X座標、Y座標、Z座標は0です。
ファイルを、3Dワールドにドラッグ＆ドロップするだけで、コンポーネントを3Dワールドのどこにでもロードすることができますが、コマンド[ジオメトリ]でインポートする場合は、CADファイルまたはジオメトリファイルを、常に3Dワールドの原点にインポートします。
次に、コンポーネントのノード構造を定義します。
コンベアの場合、コンベアの脚は回転させず、テーブルのジオメトリを回転させたいので、ジオメトリを、新しいフィーチャと新しいノードに移動する必要があります。
コンポーネントを選択した状態で、[モデリング]タブをクリックします。
コンポーネントグラフでは、コンポーネントのルートがコンポーネントと同じ名前になっていることが確認できます。
ルートノードを選択し、コンポーネントプロパティを確認していきます。
ルートノードとコンポーネントの名前を変更するので、[名前]にTurn Unitと入力します。
コンポーネントグラフの下にある、ノードフィーチャツリーを展開すると、コンポーネントにインポートされた全てのジオメトリが、1つのジオメトリフィーチャに含まれていることがわかります。
テーブルのジオメトリを、他のジオメトリと分割する必要があります。
[ジオメトリ]グループの[ツール]をクリックし、[スプリット]と呼ばれるコマンドを使用します。
スプリットは[フィーチャ]ウィンドウで、[スプリットレベル]を変更し、ジオメトリを分割します。
テーブルの全てのジオメトリを、選択する必要があるので、3Dワールドでロールバーをクリックすると、緑色にハイライトされます。
Ctrlキーを押しながらロールバーをクリックすると、複数のジオメトリを選択すことができます。
Ctrlキーを押しながらサイドレールも選択します。
テーブルをサポートしているプレートも選択したいので、プレートをクリックします。
ジオメトリを新しいフィーチャに移動したいので、[スプリットフィーチャ]ウィンドウの、[スプリット]ボタンをクリックします。
ノードフィーチャツリーで、ジオメトリが分割されたことが確認できます。
次に、元のジオメトリを選択すると、コンベアの脚と土台のみがハイライトされ、テーブルジオメトリを選択すると、テーブルのみがハイライトされます。
[ジオメトリ]グループの[ツール]をクリックすると、抽出の中に[リンク]というコマンドがあります。
コンポーネント内に新しいノードを作成し、選択したジオメトリを、ノードに移動させることができます。
[リンク]をクリックすると、新しいノードが選択され、3Dワールドでジオメトリが、青色にハイライトされます。
コンポーネントグラフを確認すると、新しいノードが追加されたことがわかります。
ノードフィーチャツリーを展開すると、テーブルのジオメトリがあります。
次に、テーブルのジオメトリに動作を設定します。
テーブルが、Z軸を中心に時計回り、または反時計回りに回転する動作を設定するために、ジオメトリを含むノードの動作の詳細設定を定義します。
コンポーネントグラフに追加したノードである、リンク1をクリックします。
[リンクプロパティ]の[JointType]を修正済みから回転に変更すると、リンクにいくつかの項目が追加されます。
[軸]が+Zであることを確認します。
[ジョイントプロパティ]では、ジョイントの名前がJ1であり、現時点ではコントローラーが設定されていないことが確認できます。
[Controller]をクリックすると、コンポーネントにサーボコントローラ、またはロボットコントローラーがまだ設定されていないため、[新規サーボコントローラ]をクリックし、サーボコントローラを追加します。
サーボコントローラは、ジョイント[J1]を制御するように設定されています。
コンポーネントグラフのビヘイビアに追加されるので、[サーボコントローラ]をクリックします。
プロパティで、[ジョイント]にJ1が設定されており、サーボコントローラがJ1を制御できるようになっています。
ルートノードにコンポーネント、フランジノードにリンクが設定されています。
リンクの動作確認を行う場合は、[マニピュレーション]グループの[インタラクティブ]機能を使用します。
ジオメトリを含むノードのジョイントプロパティが、ノードの移動を自動的に定義するので、ノードを操作すると、テーブルのジオメトリが移動し、Z軸を中心に回転していることが確認できます。
ジョイントの移動をリセットする場合、シミュレーションのリセットボタンをクリックすると、ジョイントの値を0にリセットすることができます。
リンク1をクリックし、プロパティの[J1]の値が0となっています。
次に、コンベアに沿って、コンポーネントを移動させるためのパスを追加します。
パスが3Dワールドの位置を参照するために、フレームを追加します。
テーブルの開始位置、中央、終了位置にフレームが必要です。
[モデリング]タブで3つのフレームを作成するので、[ジオメトリ]グループの[フィーチャ]をクリックし、[フレーム]を選択すると、新しいフレームを追加されます。
名前をBeginFrameに変更し、フレームの位置を変更するために、座標Zに700と入力し、テーブルの上面に移動させ、座標Xに-600と入力し、テーブルの開始位置に移動させます。
3Dワールドでフレームのラベルが見えない場合、3Dワールドツールバーにある[フレームタイプ]をクリックし、[フレーム]のチェックボックスにチェックをつけます。
フレームのラベルが表示されました。
次に、中央と終了位置にフレームを追加します。
同じ手順なので、[ジオメトリ]グループの[フィーチャ]から[フレーム]を選択します。
新しいフレームの名前をMidFrameに変更し、座標Zに700と入力し、テーブルの高さに移動し、X座標はデフォルトの位置がテーブルの中央なので、変更しません。
終了位置にフレームを追加し、移動します。
[ジオメトリ]グループの[フィーチャ]から[フレーム]を選択し、新しいフレームを追加します。
名前をEndFrameに変更し、座標Zに700と入力し、テーブルの高さに移動し、座標Xに600と入力し、テーブルの終了位置に移動させます。
BeginFrame、MidFrame、EndFrameを追加することができました。
次に、ワンウェイパスを追加し、コンベアに沿ってコンポーネントを移動できるようにする必要があります。
[動作設定]グループの[ビヘイビア]を展開し、[Material Flow]の中からワンウェイパスを選択します。
パスはフレームの位置を参照する必要があります。
ワンウェイパスのプロパティにある[パス]の矢印ボタン、プラスボタンとクリックしていきます。
参照するフレームを選択し、コンポーネントを移動する順序をパスに設定することができます。
BeginFrame、MidFrame、EndFrameの順番に選択します。
誤ってパスにフレーム追加してしまったら、フレームの横にある矢印ボタンをクリックすることで、並べ替えることができます。
次に、コンポーネントがテーブルの中央に到達したとき、検出できるセンサーとシグナルを、パスに追加します。
最初に、シグナルを作成します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]の中からブール型を選択します。
ブール型シグナルの名前をCenterSignalに変更します。
センサーを作成するので、もう一度[ビヘイビア]を展開し、[センサー]の中からパスを選択します。
コンポーネントパスセンサーが作成されたので、センサーをMidFrameの位置に配置します。
コンポーネントの原点が、MidFrameの位置を超えたとき、センサーが検知するために、コンポーネントパスセンサーのプロパティにある[フレーム]にMidFrameを設定し、[トリガー]と[リセット]で原点を選択します。
コンポーネントを検知したとき、検知を知らせるため、[ブールシグナル]にCenterSignalを設定することで、センサーがコンポーネントを検知するとTrue値でシグナルを送信し、センサーがリセットされるとFalse値で送信します。
次に、センサーをパスに追加します。
コンポーネントグラフからワンウェイパスを選択し、プロパティの[センサー]にある矢印ボタン、プラスボタンをクリックします。
コンポーネントパスセンサーを選択することで、パスに追加することができます。
[センサー]にコンポーネントパスセンサーが追加されたので、折りたたみ、次の手順に移ります。
前の手順と同様に、コンポーネントが、テーブルを離れるタイミングを知るために、センサーとシグナルを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]の中から[ブール型]を選択し、新しいブール型シグナルを作成します。
シグナルの名前をExitSignalに変更します。
センサーを追加するので、[動作設定]グループの[ビヘイビア]に戻り、[センサー]の中から[パス]を選択し、新しいコンポーネントパスセンサーを追加します。
センサーをEndFrameの位置に配置する必要があるので、プロパティの[フレーム]をEndFrameに設定し、コンポーネントの最後のエッジがセンサー位置を超えたとき、コンポーネントを検知するために、[トリガー]と[リセット]でトレーリングエッジを、選択する必要があります。
ブールシグナルにExitSignalを設定し、コンポーネントがパスを離れると、True値でシグナルを送信し、コンポーネントが完全にパスから外れると、False値で送信します。
センサーをパスに追加します。
コンポーネントグラフからワンウェイパスを選択し、プロパティの[センサー]にある矢印ボタン、プラスボタンをクリックし、コンポーネントパスセンサー2を選択し、パスに追加します。
[センサー]にコンポーネントパスセンサーが追加されたので、折りたたみ、次の手順に移ります。
次に、回転するコンベアと別のコンベアとの間で、コンポーネントの転送を行うためのインターフェースを追加します。
回転するコンベアには、コンポーネントが入出力される場所を参照する、フレームが必要です。
コンポーネントは、BeginFrameの位置に入力され、パスに沿って流れ、ExitSignalの位置から出力されますが、テーブルが回転するので、コンベアの横に入力する位置を示すフレームを、追加する必要があります。
フレームを作成するために、コンポーネントグラフのルートノードを選択し、[ジオメトリ]グループの[フィーチャ]を展開します。
[フレーム]をクリックし、新しいフレームを追加し、[名前]をEnterFrameに変更します。
EnterFrameを、コンポーネントがコンベアに入力される位置に移動します。
テーブルと同じ高さに設定するので、座標Zは700です。
BeginFrameがある位置に移動するので、X座標を-600に変更します。
テーブルが回転すると、EnterFrameは移動しませんが、テーブルとともに回転するフレームもあります。
リセットボタンをクリックします。
次に、コンベアの横に出力する位置を示すフレームを追加します。
[ジオメトリ]グループに戻り、[フィーチャ]を展開し、[フレーム]を選択し、新しいフレームを追加します。
[名前]をExitFrameに変更します。
テーブルと同じ高さに設定するので、座標Zは700です。
フレームをコンベアの横に移動する必要があります。
座標Yを600に変更します。
テーブルが回転すると、ENdFrameとExitFrameが異なる方向を指すので、ExitFrameを、Z軸を中心に90度回転させる必要があります。
座標Rzに90と入力します。
ExitFrameのX軸の方向が変化し、テーブルを回転させると、X軸が、EndFrameと同じ方向を指していることが確認できます。
リセットボタンをクリックします。
次に、インターフェース追加します。
EnterFrameの位置に入力インターフェースを、ExitFrameの位置に出力インターフェースを追加することで、別のコンポーネントと接続することができます。
[動作設定]グループの[ビヘイビア]を展開し、[インターフェース]の中から[1対1接続]をクリックし、新しいインターフェースを追加します。
1対1接続に新しいセクションを追加し、接続する位置を設定するので、[セクションフレーム]でEnterFrameを選択します。
新しい[Flow]と呼ばれるフィールドを追加し、コンポーネントをあるコンテナから別のコンテナに転送するために、[Container]でワンウェイパスを選択します。
パスの入力ポートでコンポーネントを受け取る必要があるので、[PortName]にInputを設定します。
入力インターフェースの設定は完了です。
次に、出力インターフェースを作成します。
[動作設定]グループの[ビヘイビア]を展開し、[1対1接続]を追加します。
新しいセクションを追加し、[セクションフレーム]にExitFrameを設定し、新しいフローフィールドを追加すると、コンポーネントをパスから別のコンテナに転送するので、[Container]はワンウェイパス、[PortName]はOutputです。
テーブルが回転すると、それらのフレームは、インターフェースや他のコンポーネントへの接続と同様に配置されたままになります。
シミュレーションをリセットし、ジョイントの値を0に戻し、次の手順に移ります。
コンベアが回転し、コンポーネントを別の方向に流すタイミングを制御するために、パイソンスクリプトを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]の中から[パイソンスクリプト]を選択すると、コンポーネントグラフのビヘイビアにパイソンスクリプトが追加されました。
パイソンスクリプトの作成場所はわかりやすい場所に作成してください。
センサーのシグナルを使用するために、シグナルをスクリプトに接続し、シグナルの値が変更されたとき、スクリプトが変化を認識できるようにする必要があります。
スクリプトエディタを一旦、最小化し、コンポーネントグラフからCenterSignalを選択します。
プロパティの[接続]の矢印ボタン、プラスボタンとクリックし、パイソンスクリプトを選択することで、シグナルとパイソンスクリプトを接続することができます。
同様に、ExitSignalとパイソンスクリプトを接続するので、コンポーネントグラフからExitSignalを選択し、プロパティの[接続]の矢印ボタン、プラスボタンとクリックし、パイソンスクリプトを選択します。
コンポーネントを、中央のセンサーが検知すると、スクリプトが認識し、終了位置のセンサーをが検知すると、再度スクリプトが認識します。
最小化したパイソンスクリプトをもとのサイズに戻します。
パイソンスクリプトには、デフォルトでvcScript importと記述してあり、パイソンスクリプトを使用するためには必要不可欠です。
On Run関数は、シミュレーションを実行すると、プログラムを実行します。
使用するオブジェクトを参照するために、変数を定義する必要があります。
comp=getComponent()と記述し、このパイソンスクリプトを含む、コンポーネントの情報を取得します。
変数compを使用し、コンポーネント内のオブジェクトを参照します。
次に、サーボコントローラを定義するために、servo=comp.findBehaviour("")と記述すると、コンポーネントのビヘイビアを参照するので、カッコ内に定義したい変数や設定の名称を記入します、ここではサーボコントローラと記述します。
次に、ワンウェイパスを定義するために、path=comp.findBehaviour("")と記述し、カッコ内にワンウェイパスと入力します。
次に、ループ処理を行うための記述をします。
app=getApplication()と記述すると、アプリケーションであるGemini全体の情報を、取得することができます。
3Dワールドでのシミュレーションの実行を制御するために、sim=app.Simulationと記述します。
while sim.IsRunning == True:と記述することで、シミュレーション実行中はプログラムをループさせます。
while True:と記述しても同様の動作をします。
実行することはできますが、エラーが起こりやすいため、条件式にシミュレーション実行中を表す式を使用しています。
次に、中央のセンサーが、シグナルをTrueの状態で送信するまで待機するため、triggerConditionという関数を使用します。
カッコ内には、プログラムを実行開始するための、トリガーとその値を記述するので、getTrigger().Value == Trueです。
パイソンと接続されているシグナルがTrueになることを待ち、この条件式を満たしたとき、次のプログラムを実行します。
次に実行するプログラムは、パスの動作を停止させるので、path.Enabled=Falseと記述します。
コンベアに2つ以上のコンポーネントを格納しないために、path.CapacityAvailable = Falseと記述し、コンポーネントの受け入れを停止します。
スクリプト開始時には、パスの動作は停止しておらず、コンポーネントも受け入れるので、path.Enabled=True、そして、path.CapacityAvailable=Trueと記述します。
そして、1度に1つのコンポーネントだけが、パス上にあることを確認するための設定をします。
コンポーネントグラフに戻り、ワンウェイパスを選択し、プロパティで、[容量]を念のため、1に設定します。
スクリプトに戻り、パスが停止している間、コンベアのジョイントを回転させるので、servo.moveJoint()と記述することで、サーボコントローラが制御しているジョイントを移動させることができます。
ジョイントを90°回転させるので、カッコ内に0,90と記述します。
ジョイントが90度回転した後、パスをオンに戻すので、path.Enabled=True、ジョイントが回転した後、コンポーネントがコンベアから出力されるまで、コンポーネントを受け入れません。
次のシグナルがTrueの状態で送信されるまで待機します。
再度TriggerCondition関数を使用します。
カッコ内に、getTrigger=Trueと記述します。
この場合、スクリプトに到達する最初のトリガーは、中央のセンサーであることが分かるので、値がTrueである限り、テーブルを回転させることができます。
コンポーネントがコンベアから出力されるまで待機するので、終了位置のセンサーもTrueになるまで待機します。
コンポーネントの出力が完了したら、コンベアを回転させ、新しいコンポーネントを受け取るように記述します。
servo.moveJointと記述し、ジョイントが元の位置に戻ったときなので、カッコ内を0,0はです。
ジョイントが移動した後、パスがコンポーネントを受け入れる設定をします。
path.CapacityAvailable=Trueと記述します。
[コンパイル]をクリックし、スクリプトを閉じます。
動作確認をする前に、コンポーネントを保存します。
[コンポーネント]グループの[保存]ボタンをクリックし、[コンポーネントを保存]ウィンドウでは、名前は変更せず、タグの入力は任意ですが、ここではTrainingと入力します。
[保存]ボタンをクリックし、Geminiのマイモデルというファイルに保存します。
[ホーム]タブに戻り、eカタログのマイモデルを確認すると、Turn Unitが表示されています。
シミュレーションを実行し、パイソンスクリプトで記述したプログラムの、動作確認をすることができます。
コンポーネントのインターフェースを確認します。
eカタログの[タイプ別モデル]にある[Conveyors]を展開し、[Visual Compoennts]をクリックします。
[Conveyor]をドラッグし、3Dワールドに追加します。
コンベアはターンユニットの入力インターフェースに接続する必要があります。
三角形が緑色に変化したので、接続されました。
もう1つコンベアを追加し、出力インターフェースに接続します。
次に、テーブルがどのように回転するかを確認するために、コンポーネントを生成するフィーダーを接続します。
eカタログの[タイプ別モデル]の下にある[Feeders]から[Shape Feeder]をドラッグし、3Dワールドに追加します。
入力インターフェースと接続したコンベアの、反対側に接続します。
動作確認をしやすくするため、フレームを非表示にします。
3Dワールドツールバーの[フレームタイプ]ボタンをクリックし、[フレーム]のチェックを外します。
全てのフレームが非表示になりました。
シミュレーションを実行します。
ボックスが生成され、コンベアを流れ、ターンユニットの中心で停止し、テーブルが回転し、ボックスが別のコンベアに流れました。
回転するコンベアのモデリングについての説明は以上となります。

=================================================================================

チャックを作ってみよう(1/3)

ワークをテーブルからテーブルへ搬送する、オリジナルのチャックの3DCADファイルをインポートして、可動部を設定する方法
https://youtu.be/CX36HcVBdwc
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_076_p1.zip

オリジナルのチャックを作成する方法について説明します。
オリジナルのチャックが完成すると、ワークをテーブルからテーブルへ搬送することができます。
本動画では、チャックの可動部の設定方法について説明します。
CADファイルをインポートします。
[ホーム]タブを選択し、[インポート]グループの[ジオメトリ]をクリックすることで、CADファイルをインポートすることができます。
[Chuck.3ds]を選択し、[開く]をクリックします。
[モデルをインポート]ウィンドウでは、インポート時のプロパティを設定することができます。
[構造]は、単一のモデルをインポートする場合、[フィーチャ]か[ノード]を選択します。
レイアウトをインポートする場合、[コンポーネント]を選択します。
[Chuck.3ds]には、レイアウトとしてインポートする部分と、単一のモデルとしてインポートする部分があります。
コンポーネントとノードを設定しやすいように、ツリー構造をシンプルにするため、[フィーチャ]を選択します。
3Dワールドに表示されるモデルは、多数の三角形で構成されており、[テッセレーションの品質]は、三角形の個数を設定することができます。
データ量の多いモデルの場合、低品質にすることで、データ量を削減することができます。
今回はデータ量が少ないため、[中位品質]に設定します。
[含める]では、インポートするとき、ジオメトリに含む要素を設定することができます。
今回は、[マークアップ]と[マテリアル]と[テクスチャー]を選択します。
[マテリアル作成ルール]では、マテリアルライブラリを作成するためのルールを設定することができます。
今回は、[常にライブラリから最も近似のものを使用します]を選択します。
[フィーチャツリー]は、フィーチャツリーの作成方法を、設定することができます。
[完全]は、CADファイルの階層構造をベースにし、すべてのジオメトリをトランスフォームフィーチャに入れ、フィーチャツリーを作成します。
CADファイルと完全に階層構造を一致させる場合、[完全]を選択します。
[最適化]は、すべてのジオメトリを同じ階層にし、[最小化]は、ジオメトリを1つにまとめることができます。
チャックの可動部を設定するとき、フィーチャツリーをシンプルにするため、[最適化]を選択します。
[ジオメトリを整理]では、ジオメトリセットを作成するルールを設定することができます。
ジオメトリセットは、フィーチャツリーの各ジオメトリの中に含まれるジオメトリのまとまりです。
メッシュを構成する三角ポリゴンの3点の合計が10000を超えると、新しいジオメトリセットが作成されます。
面ごとにジオメトリセットを作成する場合、[面による]を、マテリアルごとの場合、[マテリアルによる]を選択します。
ジオメトリセットを1つにまとめる場合、[折りたたみ]を、曲線のジオメトリセットを作成する場合、[数学的データ]を選択します。
今回は、[マテリアルによる]を選択します。
[上軸]は、ジオメトリの上面と底面を整列させる軸を設定することができます。
[上軸]で[-X]を選択し、[インポート]をクリックします。
チャック、ワークおよびテーブルのCADファイルをインポートすることができます。
ワークを、チャックとは別のコンポーネントに分けるため、[モデリング]タブを開きます。
3Dワールドで、赤い箱のジオメトリをすべて選択します。
コントロールキーを押した状態で、選択することで、複数のジオメトリを選択することができます。
右クリックして、メニューを開きます。
[抽出]から[コンポーネントを抽出]を選択することで、選択したジオメトリを新しいコンポーネントに抽出することができます。
コンポーネントの名前を、Workに変更します。
同様に、茶色のテーブルと、オレンジのテーブルを別のコンポーネントに分けます。
茶色のテーブルをテーブルA、オレンジのテーブルをテーブルBとします。
名前をTableAと、TableBに変更します。
チャックの可動部を設定します。
チャックには、X軸方向に動作する可動部と、Z軸方向に動作する可動部と、ワークをつかむハンドがあります。
X軸方向の可動部を設定します。
チャックの青い部分を選択します。
右クリックして、メニューを開きます。
[抽出]から[抽出リンク]を選択することで、選択したジオメトリを新しいノードに抽出することができます。
[コンポーネントグラフ]ウィンドウに、「Link_1」が追加されたことがわかります。
Link_1に動作の詳細を設定します。
[リンクプロパティ]ウィンドウで[JointType]を設定することで、動作の種類を定義することができます。
固定は、動作は設定せず、ノードを固定することができます。
回転は、定義した軸を中心に回転運動し、直進は、定義した軸に沿って直線運動することができます。
回転フォロワーは、別のノードの運動量に基づき、定義した軸を中心に回転運動し、変換フォロワーは、運動量に基づき、直線運動することができます。
カスタムは、定義した軸を基準に、回転運動か直線運動することができます。
今回は、直進を選択します。
可動部が動作する方向を設定します。
[軸]で+Xを選択します。
可動部が動作する方向を確認します。
[マニピュレーション]グループの[インタラクティブ]を選択することで、可動部の動作を確認することができます。
3Dワールドで「Link_1」をドラッグします。
「Link_1」が、X軸方向に動作することがわかります。
シミュレーションのリセットボタンをクリックすることで、可動部が初期位置に戻ります。
[リンクプロパティ]ウィンドウの[Controller]は、ノードの動作を制御するコントローラーを定義することができます。
[Controller]をクリックし、「新規サーボコントローラ」を選択します。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]を展開すると、サーボコントローラが追加されたことがわかります。
Geminiのサーボコントローラは、一般的なサーボコントローラとは異なり、可動部を制御する仮想のコントローラーです。
[リンクプロパティ]ウィンドウの[初期値]はノードの初期位置、[J1]はノードの現在位置を表示しています。
現在、[初期値]と[J1]は0です。
[最小リミット]と[最大リミット]は、ノードの可動範囲の最小値と最大値を定義することができます。
[最小リミット]を0、[最大リミット]を500に設定します。
3Dワールドで「Link_1」をドラッグします。
「Link_1」が、[最小リミット]と[最大リミット]の範囲外に動作すると、[リンクプロパティ]ウィンドウの[J1]にエラーが発生します。
範囲外に動作しない設定にする場合、[プログラム]タブをクリックし、[リミット]グループの[リミットで停止]にチェックを付けます。
[モデリング]タブをクリックします。
3Dワールドで、「Link_1」をドラッグし、範囲外に動作しないことを確認します。
リセットボタンをクリックします。
Z軸方向の可動部を設定します。
コントロールキーを押した状態で、チャックの灰色の部分をすべて選択します。
右クリックして、メニューを開きます。
[抽出]から[抽出リンク]を選択し、新しいノードに抽出します。
[コンポーネントグラフ]ウィンドウに、「Link_2」が追加されたことがわかります。
Link_2に動作の詳細を設定します。
ワークをつかむ高さを調節するため、[リンクプロパティ]ウィンドウで[JointType]を「直進」、[軸]を「-Z」に設定します。
既存のノードとは、異なるタイミングで動作できるようにするため、[Controller]をクリックし、「新規サーボコントローラ」を選択します。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]に、サーボコントローラ_2が追加されたことがわかります。
「Link_2」の可動範囲を設定するため、[リンクプロパティ]ウィンドウで[最小リミット]を「0」、[最大リミット]を「130」に設定します。
3Dワールドで「Link_2」をドラッグします。
「Link_2」が、Z軸方向に動作することがわかります。
3Dワールドで「Link_1」をドラッグします。
「Link_2」は、「Link_1」の動作に追従しないため、「Link_1」の動作に追従するように設定します。
リセットボタンをクリックします。
[コンポーネントグラフ]ウィンドウの「Link_2」をシフトキーを押した状態で、ドラッグ＆ドロップし、Link_1に入れます。
シフトキーを押し忘れてジオメトリが移動した場合、シフトキーを押さずにドラッグ＆ドロップで、ノードから出すことで、ジオメトリを元の位置に戻すことができます。
新しいノードを追加するとき、[コンポーネントグラフ]ウィンドウの「Link_1」を選択した状態で、[構造]グループの[リンクをクリエイト]をクリックすることで、自動的に「Link_1」の子階層に入れることもできます。
3Dワールドで「Link_1」をドラッグします。
「Link_2」は、「Link_1」の動作に追従することがわかります。
リセットボタンをクリックします。
ワークをつかむハンドを設定します。
コントロールキーを押した状態で、ハンドの片側を選択します。
右クリックして、メニューを開きます。
[抽出]から[抽出リンク]を選択し、新しいノードに抽出します。
[コンポーネントグラフ]ウィンドウに、「Link_3」が追加されたことがわかります。
同様に、ハンドの反対側も新しいノードに抽出します。
[コンポーネントグラフ]ウィンドウに、「Link_4」が追加されたことがわかります。
Link_3に動作の詳細を設定します。
ワークをつかむ動作をするため、[リンクプロパティ]ウィンドウで[JointType]を「直進」、[軸]を「-Y」に設定します。
既存のノードとは、異なるタイミングで動作できるようにするため、[Controller]をクリックし、「新規サーボコントローラ」を選択します。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]に、「サーボコントローラ_3」が追加されたことがわかります。
「Link_3」の可動範囲を設定するため、[リンクプロパティ]ウィンドウの[最小リミット]を「0」、[最大リミット]を「10」に設定します。
「Link_3」が、「Link_1」と「Link_2」の動作に追従するように設定します。
[コンポーネントグラフ]ウィンドウの「Link_3」をシフトキーを押した状態で、ドラッグ＆ドロップし、Link_2に入れます。
Link_4に動作の詳細を設定します。
ワークをつかむとき、「Link_3」の動作に連動して、Link_3とは反対方向に動作するため、[リンクプロパティ]ウィンドウで[JointType]を「変換フォロワー」、[軸]を「+Y」に設定します。
[ドライバー]は、動作を連動させるために参照する別のノードの運動量を設定します。
[ドライバー]をクリックし、サーボコントローラ_3のJ3を選択します。
「Link_4」が、「Link_1」と「Link_2」の動作に追従するように設定します。
[コンポーネントグラフ]ウィンドウの「Link_4」をシフトキーを押した状態で、ドラッグ＆ドロップし、Link_2に入れます。
3Dワールドで「Link_3」をドラッグします。
「Link_4」が、「Link_3」の動作に連動し、Link_3とは反対方向に動作することがわかります。
3Dワールドで「Link_1」と「Link_2」をドラッグします。
Link_3とLink_4は、「Link_1」と「Link_2」の動作に追従することがわかります。
リセットボタンをクリックします。
チャックの可動部の設定方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

チャックを作ってみよう(2/3)

オリジナルのチャックの、ワークを検出する方法と、ワークを格納するコンテナの設定方法
https://youtu.be/kuU8d_tkkBY
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_076_p2.zip

チャックで、ワークを搬送するために必要な設定について説明します。
本動画は、チャックの可動部の設定方法の続きから設定します。
チャックの可動部の設定が、完了しているファイル[Chuck1_after.vcmx]が必要です。
ワークを搬送するためには、コンポーネントに、別のコンポーネントを格納することができる、コンテナという設定を使用します。
チャックと搬送先にコンテナを設定し、チャックのコンテナにあるワークを、搬送先のコンテナへ格納する必要があります。
ワークは、X軸方向の動作と、Z軸方向の動作に連動して移動するため、[コンポーネントグラフ]ウィンドウで「Link_2」を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[マテリアルフロー]から[コンポーネントコンテナ]を選択します。
同様に、テーブルBにコンテナを追加します。
テーブルBを選択します。
[動作設定]グループの[ビヘイビア]を展開し、[マテリアルフロー]から[コンポーネントコンテナ]を選択します。
ワークを搬送するため、センサーを設定します。
今回は、シミュレーション開始前からワークを配置していますが、シミュレーション後にワークを生成する場合もあります。
ワークは、生成時にランダムな名前が付与されます。
ワークの情報を取得するため、ワークを検出するセンサーが必要です。
センサーの位置を設定します。
センサーの位置は、チャックの「Link_1」と「Link_2」の動作に連動して移動するため、チャックの灰色の部分をダブルクリックします。
[コンポーネントグラフ]ウィンドウで、Chuckの「Link_2」が選択されたことがわかります。
[ジオメトリ]グループの[フィーチャ]を展開し、[その他]から[フレーム]を選択します。
フレームは、3Dワールド上で、位置と方向を定義する基準点です。
3Dワールドに、フレームが表示されない場合、3Dワールドツールバーのフレームタイプを開き、フレームにチェックを付けます。
3Dワールドにフレームを表示することができます。
フレームを移動させるため、[ツール]グループの[スナップ]を選択します。
フレームが、ハンドやワークに重ならないように注意します。
ハンドとフレーム、またはワークとフレームが重なっている場合、センサーはワークを検出することができません。
3Dワールドで、ハンドの中心をクリックします。
ワークを検出するため、センサーを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[センサー]から[レイキャスト]を選択します。
レイキャストセンサーは、定義したフレームの位置から光線を照射し、光線と交差したコンポーネントを検出することができます。
センサーの位置を、フレームを選択して、定義します。
[プロパティ]ウィンドウの[フレーム]をクリックし、フレームを選択することで、フレームの+Z軸方向に光線を照射することができます。
表示する光線の長さと、ワークを検出する範囲を設定します。
[最大範囲]は、3Dワールドに表示する光線の長さを設定し、[検出しきい値]は、コンポーネントを検出する範囲を設定することができます。
[最大範囲]と[検出しきい値]を30に変更します。
光線を非表示にするときは[光線表示]のチェックを外し、光線を表示するときは[光線表示]にチェックを付けます。
今回は、[光線表示]にチェックを付けます。
[コンポーネントシグナル]は、検出したコンポーネントを値として格納するシグナルを定義します。
センサーで検出したワークの情報を格納するため、シグナルを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[コンポーネント]を選択します。
コンポーネントシグナルは、コンポーネントを値として送受信することができます。
[コンポーネントグラフ]ウィンドウでRaycastSensorを選択します。
[プロパティ]ウィンドウの、[コンポーネントシグナル]でComponentSignalを選択します。
ワークを搬送する場合、ワークがチャックのコンテナに格納された状態で、再度センサーでワークを検出し、テーブルのコンテナにワークを格納します。
ワークがチャックのコンテナに格納されている状態のとき、ワークはチャックのコンポーネント内にあります。
センサーはデフォルトの設定では、同じコンポーネント内にあるジオメトリを検出することはできません。
[親テスト]にチェックがついていない場合、RaycastSensorを含むコンポーネント以外のジオメトリのみを検出することができます。
[親テスト]にチェックをつけることで、RaycastSensorを含むコンポーネント内のジオメトリも検出することができます。
今回は、[親テスト]にチェックをつけます。
チャックが動作するタイミングを指示するため、シグナルを追加します。
[コンポーネントグラフ]ウィンドウで、[Chuck]を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[ブール型]を選択します。
ブール型シグナルは、オンオフを送受信することができます。
名前をBackに変更します。
同様に、ブール型シグナルを5つ追加します。
名前は、Front、Up、Down、Open、Closeです。
Backがオンのとき、「Link_1」をテーブルAの位置、Frontがオンのとき、「Link_1」をテーブルBの位置に移動します。
Downがオンのとき、「Link_2」をワークの高さまで移動し、Upがオンのとき、「Link_2」を元の高さに戻します。
Openがオンのとき、ハンドを開き、Closeがオンのとき、ハンドを閉じます。
チャックの動作完了を通知するため、プロパティを追加します。
[プロパティ]グループの[プロパティ]を展開し、[ベーシック]から[ブール型]を選択します。
プロパティは、コンポーネントのグローバル変数であり、プログラム内のどこからでも使用することができます。
名前をX1に変更します。
同様に、ブール型プロパティを5つ追加します。
名前は、X2、X3、X4、X5、X6です。
X1はBackの動作が完了したとき、オンになります。
同様に、X2はFront、X3はUp、X4はDown、X5はOpen、X6はCloseの動作が完了したとき、オンになります。
本動画では、X1からX6の各状態を判別し、使用することはありません。
PLCと連携し、ラダー回路でチャックの動作を制御するときに使用するため、参考としてX1からX6を追加しています。
チャックで、ワークを搬送するために必要な設定についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

チャックを作ってみよう(3/3)

オリジナルのチャックのワーク搬送を、パイソンスクリプト（Python）で制御する方法
https://youtu.be/rZ7oFdWg0RI
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_076_p3.zip

チャックの動作をパイソンスクリプトで制御し、ワークを搬送する方法について説明します。
本動画は、チャックでワークを搬送するために必要な設定の続きから設定します。
チャックでワークを搬送するために必要な設定が、完了しているファイル[Chuck2_after.vcmx]が必要です。
パイソンスクリプトを追加し、チャックを動作させるプログラムを記述します。
チャックがX軸方向に動作するためのパイソンスクリプトを追加するため、[コンポーネントグラフ]ウィンドウで「Link_1」を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
エディタが自動的に開くため、デフォルトで記述されているソースコードを1行目以外削除します。
パイソンスクリプトを含むコンポーネントの情報を取得するため、comp=getComponent()と記述します。
servo=comp.findBehaviourと記述することで、コンポーネントのビヘイビアを参照することができます。
カッコ内にサーボコントローラと記述し、名前を指定します。
シグナルを参照するため、back=comp.findBehaviour("Back")と記述します。
同様に、ビヘイビアのFrontを参照します。
X1a=comp.getPropertyと記述することで、コンポーネントのプロパティを参照することができます。
カッコ内にX1と記述し、名前を指定します。
同様に、X2a=comp.getProperty("X2")と記述し、プロパティのX2を参照します。
def OnRun():と記述することで、シミュレーションの開始時にプログラムを実行することができます。
チャックの初期状態と、プロパティの値を一致させるため、プロパティに初期値を設定します。
PLCと連携し、チャックを制御する場合、チャックの状態を判別する必要があります。
[コンポーネントグラフ]ウィンドウのX1、X2は、チャックの「Link_1」の状態を示します。
X1がTrueのとき、「Link_1」がテーブルAの位置にある状態です。
X2がTrueのとき、「Link_1」がテーブルBの位置にある状態です。
シミュレーション開始時、「Link_1」はテーブルAの位置にあるため、X1aをTrue、X2aをFalseに設定します。
while True:と記述し、以下のプログラムをループさせます。
triggerCondition(lambda:getTrigger()==back or getTrigger()==front)と記述することで、backかfrontのオンオフが切り替わるまで、以下のプログラムを実行せず、待機することができます。
backがTrueの場合、「Link_1」をテーブルAの位置に移動します。
X2a.Value=Falseと記述し、「Link_1」がテーブルBの位置にあることを示すX2をオフにします。
「Link_1」をテーブルAの位置に移動するため、servo.moveJoint(0,0)と記述します。
moveJointメソッドは、サーボコントローラのノードを、移動させることができます。
カッコ内の最初の0は、サーボコントローラに定義されているノードリストの0番目を表しています。
2つ目の0は、ノードが移動する目標位置です。
X1a.Value=Trueと記述し、「Link_1」がテーブルAの位置に移動完了したことを示します。
frontがTrueの場合、「Link_1」をテーブルBの位置に移動します。
X1a.Value=Falseと記述し、「Link_1」がテーブルAの位置にあることを示すX1をオフにします。
「Link_1」をテーブルBの位置に移動するため、servo.moveJoint(0,500)と記述します。
X2a.Value=Trueと記述し、「Link_1」がテーブルBの位置に移動完了したことを示します。
コンパイルをクリックします。
先程PythonScriptに記述したtriggerConditionで、BackとFrontをトリガーとして使用するため、接続します。
[コンポーネントグラフ]ウィンドウのBackを選択します。
[プロパティ]ウィンドウの[接続]をクリックし、PythonScriptを選択します。
同様に、FrontとPythonScriptを接続します。
チャックがZ軸方向に動作するためのパイソンスクリプトを追加するため、[コンポーネントグラフ]ウィンドウで「Link_2」を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
PythonScript_2のプログラム内容は、PythonScriptと類似しているため、PythonScriptのプログラムをコピーし、PythonScript_2に貼り付けます。
PythonScript_2を編集します。
4行目で参照しているサーボコントローラの名前を、サーボコントローラ_2に変更します。
5行目の変数名をupに、参照しているシグナルの名前を、Upに変更します。
6行目の変数名をdownに、参照しているシグナルの名前を、Downに変更します。
7行目の変数名をX3aに、参照しているプロパティの名前を、X3に変更します。
8行目の変数名をX4aに、参照しているプロパティの名前を、X4に変更します。
プロパティの初期値を設定します。
X3、X4の値は、チャックの「Link_2」の状態を示します。
X3がTrueのとき、「Link_2」が0の位置にある状態です。
X4がTrueのとき、「Link_2」がワークの高さにある状態です。
シミュレーション開始時、「Link_2」がワークの高さの位置にないため、X3aをTrue、X4aをFalseに設定します。
triggerConditionでトリガーとして使用するシグナルを、upとdownに変更します。
upがTrueの場合、「Link_2」を0の位置に移動します。
X4aをFalseに設定することで、「Link_2」がワークの高さにないことを示します。
servo.moveJoint(0,0)で、「Link_2」を0の位置に移動します。
X3aをTrueに設定することで、「Link_2」が0の位置に移動完了したことを示します。
downがTrueの場合、「Link_2」をワークの高さに移動します。
X3aをFalseに設定することで、「Link_2」が0の位置にないことを示します。
ワークの高さに移動するため、servo.moveJoint(0,130)に変更します。
X4aをTrueに設定することで、「Link_2」がワークの高さに移動完了したことを示します。
コンパイルをクリックします。
PythonScript_2に記述したTriggerConditionで、UpとDownをトリガーとして使用するため、接続します。
[コンポーネントグラフ]ウィンドウでUpを選択します。
[プロパティ]ウィンドウの[接続]でPythonScript_2を選択します。
同様に、DownとPythonScript_2を接続します。
ハンドに開閉する動作と、コンテナに格納するプログラムを設定し、ワークをつかみ、つかんでいるワークを放します。
ワークをつかみ、放すためのパイソンスクリプトを追加するため、[コンポーネントグラフ]ウィンドウで「Link_3」を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
PythonScript_3のプログラム内容は、PythonScript_2と類似しているため、PythonScript_2のプログラムをコピーし、PythonScript_3に貼り付けます。
PythonScript_3を編集します。
4行目で参照しているサーボコントローラの名前を、サーボコントローラ_3に変更します。
5行目の変数名をopenに、参照しているシグナルの名前を、Openに変更します。
6行目の変数名をcloseに、参照しているシグナルの名前を、Closeに変更します。
7行目の変数名をX5aに、参照しているプロパティの名前を、X5に変更します。
8行目の変数名をX6aに、参照しているプロパティの名前を、X6に変更します。
ワークの情報を取得するため、センサーで検出したコンポーネントを格納するシグナルを参照します。
signal=comp.findBehaviour("ComponentSignal")と記述します。
チャックに、ワークを追従させるため、コンテナを参照します。
cont=comp.findBehaviour("ComponentContainer")と記述します。
搬送先のテーブルBのコンテナに、ワークを格納するため、テーブルBを参照する必要があります。
チャックのコンポーネント以外のコンポーネントを参照する場合、まずGeminiのアプリケーションにアクセスします。
Geminiのアプリケーションにアクセスするため、app=getApplication()と記述します。
次に、参照するコンポーネントを指定します。
テーブルBを参照するため、tableB=app.findComponent("TableB")と記述します。
最後に、コンポーネント内の参照するビヘイビアを指定します。
コンテナを参照するため、cont2=tableB.findBehaviour("ComponentContainer")と記述します。
プロパティの初期値を設定します。
X5、X6の値は、チャックのハンドの状態を示します。
X5がTrueのとき、ハンドが開いている状態です。
X6がTrueのとき、ハンドが閉じている状態です。
シミュレーション開始時、ハンドは開いているため、X5aをTrue、X6aをFalseに設定します。
triggerConditionでトリガーとして使用するシグナルを、openとcloseに変更します。
openがTrueの場合、ハンドを開き、つかんでいるワークを放します。
X6aをFalseに設定することで、ハンドが閉じていないことを示します。
センサーで検出したコンポーネントをワークとして定義するため、work=signal.Valueと記述します。
ワークをテーブルBのコンテナに格納します。
grabメソッドを使用することで、コンテナやパスにコンポーネントを格納することができます。
cont2.grab(work)と記述します。
servo.moveJoint(0,0)で、ハンドを開きます。
X5aをTrueに設定することで、ハンドが開いたことを示します。
closeがTrueの場合、ハンドを閉じ、ワークをチャックのコンテナに格納します。
X5aをFalseに設定することで、ハンドが開いていないことを示します。
servo.moveJoint(0,10)に変更し、ハンドを閉じます。
ワークを定義するため、work=signal.Valueと記述します。
cont.grab(work)と記述し、チャックのコンテナにワークを格納します。
X6aをTrueに設定することで、ハンドが閉じたことを示します。
コンパイルをクリックします。
PythonScript_3に記述したtriggerConditionで、OpenとCloseをトリガーとして使用するため、接続します。
[コンポーネントグラフ]ウィンドウでOpenを選択します。
[プロパティ]ウィンドウの[接続]でPythonScript_3を選択します。
同様に、CloseとPythonScript_3を接続します。
シミュレーションを実行します。
[接続]グループの[シグナル]をクリックし、チャックを選択することで、シグナルエディタを表示することができます。
Down、Closeの順にオンにすることで、ワークをつかみます。
Downをオフにし、Up、Frontの順にオンにすることで、テーブルBの位置まで移動します。
Upをオフにし、Downをオンにします。
Closeをオフにし、Openをオンにすることで、ワークを放します。
Downをオフにし、Upをオンにすると、ワークは、チャックの動作に追従しないため、テーブルBのコンテナに格納されたことがわかります。
チャックで、ワークを搬送するとき、パイソンスクリプトで制御する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ツーウェイパスを使ってみよう

オリジナルの装置やコンベアの上を、製品が前後の双方向に流れる設定方法
https://youtu.be/6FLto4g76BQ
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_011.zip

ツーウェイパスの説明をします。
ツーウェイパスはコンポーネントをパスに沿って前後に移動させることができます。
3Dワールドにあるオレンジ色のブロックにツーウェイパスを設定しコンベアにします。
コンベアを選択することでロボットがワークをコンベア上に配置しワークはパスに沿い前方に移動します。
パスは開始位置と終了位置を定義します。
ワークは同じパスに沿い終了位置から開始位置まで後方に移動し方向が変更されます。
動作はコンポーネントプロパティで確認することができます。
ツーウェイパスをクリックします。
方向は「Forward」のためワークは前方に移動します。
Pythonスクリプトの記述によりパスのロジックを制御します。
方向を「Backward」に変更しワークが後方に移動します。
ロボットがワークを持ち上げることで方向が「Forward」に変更されるため次のワークを配置し移動させることができます。
ツーウェイパスを設定します。
ツーウェイパスを設定するために新しいコンポーネントを作成します。
eカタログからモデルを配置します。
タイプ別モデルにある「Conveyor」をクリックしモデルを配置します。
このモデルにはツーウェイパスが設定されているためテンプレートとして使用することができます。
また[ジオメトリ]グループの[インポート]（正しくは[インポート]グループの[ジオメトリ]）でCADファイルをインポートしモデル化することでツーウェイパスを作成することもできます。
新しいコンポーネントを作成します。
[モデリング]タブをクリックしコンポーネントグループの新規をクリックし新しいコンポーネントを3Dワールドに作成します。
コンポーネントの名前を変更します。
[コンポーネントプロパティ]の名前からTwo Way Conveyorと入力します。
コンポーネントにジオメトリを追加します。
[ジオメトリ]グループの[フィーチャ]をクリックし[ボックス]をクリックすることで「ブロック」をコンポーネントに追加します。
[フィーチャプロパティ]に移動し「ブロック」の寸法を変更します。
長さを1000、幅を400に、高さを700に設定します。
次に経路の座標をパスで参照するためフレームをコンポーネントに追加します。
ブロックの上面にパスを設定しパスに沿いワークを移動させる必要があります。
ブロックのエッジの中点にフレームを追加し開始位置と終了位置を設定します。
[ジオメトリ]グループの[フィーチャ]をクリックしフレームをクリックすることで新しいフレームを追加します。
3Dワールドにフレームのラベルが表示されない場合3Dワールドツールバーのフレームタイプをクリックしフレームにチェックを付けます。
移動でフレームを移動するためエッジの中点にドラッグします。
フレームの向きを変更します。
デフォルトではX軸は現在赤い矢印がさしている方向のためフィーチャプロパティでRxが0であることが確認できます。
RyとRzも0です。
コンポーネントを接続するインターフェースに設定します。
コンポーネントをツーウェイパスに接続することでワークはフレームの方向に基づき移動します。
プロパティでフレームの名前をインフレームAに設定します。
別のフレームを追加するため[ジオメトリ]グループの[フィーチャ]をクリックしフレームをクリックすることで新しいフレームを追加します。
移動でフレームを別のエッジの頂点に移動します。
フレームの方向を確認します。
Rx、Ry、Rzは0です。
プロパティでフレームの名前をアウトフレームAに設定します。
ツーウェイパスの動作を追加します。
動作設定グループのビヘイビアをクリックしマテリアルフローの中からツーウェイパスを選択することで新しいツーウェイパスを追加することができます。
ツーウェイパスでフレームを参照する必要があります。
プロパティに移動します。
パスを展開し+ボタンをクリックします。
フレームをワークを流す順番に追加します。
インフレームAアウトフレームAの順番でクリックし[Add Path items]ウィンドウを閉じます。
ワークをツーウェイパスに沿って移動させる設定をします。
[コンポーネントグラフ]に移動しツーウェイパスを展開します。
InputポートとOutputポートの2つのポートが表示されます。
Outputポートはツーウェイパスの終了位置からワークを出力しInputポートはツーウェイパスの開始位置にワークを入力しています。
Inputポートを選択しプロパティに移動します。
入力と出力という2つの選択肢があり入力にチェックをつけた場合、ワークを別の場所からツーウェイパスの開始位置に入力することができ、入力と出力にチェックをつけた場合ワークをツーウェイパスの開始位置から別の場所に出力、または別の場所から開始位置に入力することができます。
Outputポートも同様に設定するため[コンポーネントグラフ]でOutputポートを選択し入力にチェックをつけることで、ワークをツーウェイパスの終了位置から別の場所に出力または別の場所から終了位置へ入力します。
ツーウェイパスはワークを前方または後方に移動することができるためツーウェイパスの開始位置から受け取るワークは前方に移動し、終了位置から受け取るワークは後方に移動することができます。
他のコンポーネントと接続するインターフェースを設定します。
動作設定グループのビヘイビアをクリックしインターフェースの中から1対1接続を選択することで新しい1対1のインターフェースを追加することができます。
コンポーネントをツーウェイパスに接続するセクションを作成します。
プロパティで[新規セクションを追加]をクリックしセクションを作成します。
ツーウェイパスの開始位置にワークを転送するためセクションフレームをインフレームAに設定します。
プロフィールドを作成しコンテナから別のコンテナにワークを転送します。
コンテナにツーウェイパスを設定しポートネームにInputを設定します。
パスの開始位置に作成した入力インターフェースを確認するため[ホーム]タブに移動します。
eカタログの[タイプ別モデル]の下にある[Feeders]をクリックしBasic Feederを3Dワールドにドラッグします。
フィーダーをコンベアに接続し三角形が緑色に変化することを確認します。
シミュレーションを再生します。
ワークはパスに転送されパスの開始位置から終了位置まで移動します。
コンベアを選択し[コンポーネントプロパティ]の[TwoWayPath]タブをクリックします。
方向はワークをパスに沿って移動させる方向を制御するプロパティです。
方向が「Forward」のためパスの開始位置から終了位置まで移動していますが方向を「Backward」に変更します。
ワークはパスの終了位置から開始位置まで移動します。
Pythonスクリプトの記述によりセンサーシグナルでツーウェイパスの方向を制御することもできます。
シミュレーションをリセットします。
フィーダーとコンベアの接続を解除しフィーダーを選択します。
フィーダーをコンベアの終了位置に接続しワークが自動的に後方に移動する設定をし、新しいインターフェースを設定する必要があります。
現時点でフィーダーをコンベアの終了位置に接続することはできません。
フィーダーの方向を回転させワークが後方に移動するようにします。
アウトフレームAはフィーダーのフレームとX軸方向が一致しません。
インターフェースを設定するため新しいフレームを追加する必要があります。
コンベアを選択し[モデリング]タブに移動します。
新しいフレームを追加するため フィーチャをクリックしフレームを選択します。
フレームをパスの終了位置まで ドラッグしますフレームの方向を変更する必要があります。
Z軸を中心に回転させるためフィーチャプロパティの座標Rzを180に変更します。
オブジェクト座標に変更しフレームのX軸方向を確認します。
フレームの位置に入力インターフェースを設定します。
コンポーネントグラフに戻り1対1のインターフェースを選択します。
[新規セクションを追加]をクリックしセクションフレームに追加したフレームを設定します。
コンテナにツーウェイパスを設定し ポートネームにOutputを設定します。
ツーウェイパスにワークを入力する ためのセクションが2つあります。
一つ目はツーウェイパスの開始位置に入力し、2つ目はツーウェイパスの終了位置に入力します。
ツーウェイパスのInputポートとOutputポートの設定ではワークの入力と出力の両方をパスに設定しました。
動作確認をします。
フィーダーを選択しコンベアに接近し緑色の矢印が表示されます。
互換性のあるインターフェースであることが確認できます。
フィーダーをコンベアに接続し三角形が緑色に変化することを確認します。
コンベアを選択し[コンポーネントプロパティ]の方向では「バックワード」が設定されています。
方向を「フォワード(自動)」に変更します。
ワークはツーウェイパスに転送され自動的に方向を変更し移動します。
[コンポーネントプロパティ]の方向を「バックワード(自動)」または「フォワード(自動)のどちらに設定してもワークが入力される場所を認識して方向を自動的に修正し移動します。
フィーダーをコンベアの終了位置に接続しているため「バックワード(自動)」に設定されワークは終了位置から後方へ移動しました。
シミュレーションをリセットします。
フィーダーとコンベアの接続を解除します。
コンベアから別のコンベアにワークを出力するためのインターフェースを設定します。
入力インターフェースと同じ手順のため開始位置からの出力をするためにフレームを作成し終了位置から出力するためにアウトフレームAを使用します。
コンベアを選択し[モデリング]タブに移動します。
別のインターフェースを設定する必要があるため動作設定グループのビヘイビアをクリックします。
インターフェースから1対1接続を選択し新しいインターフェースを追加します。
[新規セクションを追加]をクリックします。
ツーウェイパスの終了位置からワークを出力するためセクションフレームにアウトフレームAを設定します。
プロフィールドを作成しコンテナにツーウェイパス、ポートネームに「Output」を設定し、ツーウェイパスの終了位置からワークを出力します。
新しいフレームとセクションを追加しツーウェイパスの開始位置からワークを出力します。
新しいフレームを追加しフレーム位置を開始位置までドラッグします。
X軸方向を変更するためZ軸を中心に回転させる必要があります。
フィーチャプロパティの座標Rzを180に設定します。
インターフェース2に戻り新しいセクションを追加します。
セクションフレームにフレーム位置を設定します。
プロフィールドを作成しコンテナにツーウェイパス、ポートネームに「Input」を設定し、ツーウェイパスの開始位置からワークを出力します。
ツーウェイパスからワークを出力するためのセクションが2つあります。
1つ目はツーウェイパスの終了位置から出力し2つ目はツーウェイパスの開始位置から出力します。
動作を確認します。
[ホーム]タブに戻りeカタログのタイプ別モデルの下にあるConveyorsを展開しVisual ComponentsをクリックしConveyorを3Dワールドにドラッグアンドドロップします。
ツーウェイコンベアの終了位置にeカタログのConveyorを接続します。
緑の矢印が表示され三角形が緑色に変化することを確認します。
ツーウェイコンベアからeカタログのConveyorに出力します。
フィーダーをツーウェイコンベアの開始位置に接続します。
コンベアに接続しフィーダーの方向が自動的に変更されます。
ツーウェイコンベアを選択し方向が「バックワード(自動)」に設定されていますがワークがツーウェイパスに入力される場所に基づき変更されます。
ワークは前方に移動します。
次のコンベアにワークを出力します。
シミュレーションをリセットします。
表示されている三角形はワークツーウェイパスから出力することができる場所になります。
開始位置の緑色の三角形はツーウェイパスを指し終了位置の緑色の三角形はツーウェイパスから外側を指しています。
終了位置の黄色の三角形はツーウェイパスの終了位置から内側を差し開始位置の黄色の三角形はツーウェイパスの開始位置から外側を指しています。
フィーダーを選択し接続を解除します。
コンベアの接続も解除します。
フレームの方向に基づきコンポーネントを接続するため誤った方向に接続される可能性があります。
コンベアを回転させ方向を確認し近づけます。
正しい方向に接続することができます。
フィーダーも同様に回転させツーウェイコンベアに近づけ接続します。
ワークを入力するためツーウェイパスの終了位置に接続します。
ツーウェイコンベアを選択します。
方向は「フォワード(自動)」に設定されていますがワークを入力する場所に基づき自動的にバックワードに変更されます。
ワークが終了位置から後方に移動し次のコンベアに出力されます。
シミュレーションをリセットします。
ツーウェイパスについての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

フィーダーを作って構造を理解してみよう

オリジナルのフィーダーを作って、機構の設定方法を理解する
https://youtu.be/LNwLBBpcg1k
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_013.zip

フィーダーをモデリングする方法を説明します。
フィーダーはシミュレーション中にワークを生成することができるコンポーネントです。
ワークはプロセスモデリングで使用することができます。
[モデリング]タブにアクセスする必要があるため、MELSOFT Gemini Professionalが必要です。
eカタログにあるフィーダーを参照します。
タイプ別モデルを展開しPM Flow Componentsをクリックします。
Feederと呼ばれるコンポーネントがあります。
フィーダーを作成していきます。
[モデリング]タブをクリックし新しいコンポーネントを作成します。
コンポーネントの名前に「My Product Feeder」と入力します。
名前の変更は任意です。
ジオメトリを追加します。
フィーチャをクリックしボックスを選択します。
寸法を変更します。
長さと幅を500に設定し高さを700に設定します。
必要な動作をフィーダーに追加するため[追加]グループの[ウィザード]をクリックし ます。
コンベアを選択します。
コンベアにカーソルを合わせることで詳細を読むことができます。
初期設定ではボックスの上面に沿いパスのフレームを作成します。
コンベアの方向をX軸方向であると仮定します。
浮動原点と矢印の赤色が指す方向です。
入力の接続は必要ありませんが、製品を別のコンベアまたはコンポーネントに流す場合、出力の接続が必要です。
インターフェースを作成します。
ワークを操作するためコンポーネント クリエーターを追加する必要はありません。
パス補間は直線で移動するため変更しませんが、独自のモデルにステップまたはキュービックを使用する場合は変更します。
コンベアの動作を作成するボタンをクリックし、コンベアの動作を作成します。
ボックスの上面にフレームを追加します。
フレームラベルのサイズを変更する場合ファイルタブに移動し、[オプション]-[ディスプレイ]とクリックします。
フレームラベルサイズは30のため10に変更します。
フレーム位置は必要ありません。
コンポーネントグラフに移動し、プロパティとビヘイビアがあることを確認します
表示されない場合検索ボックスの横にあるアイコンをクリックすることで、表示を切り替えることができます。
プロパティの表示切り替えです。
ビヘイビアの表示切り替えです。
ビヘイビアにはStatisticsが追加されパスの内外にコンポーネントを移動させることができるインプットとアウトプットを持つパスがあり、パスを別のコンポーネントに接続する出力インターフェース、外部センサーをパスに接続することができるセンサーインターフェースがあります。
センサーインターフェースは必要ないため、右クリックし削除します。
パスはブロックの先頭にフレームがある必要はないためパスのプロパティに移動します。
パスを展開し「PathFrame_1」のゴミ箱アイコンをクリックし削除します。
パスは「PathFrame_2」から「PathFrame_3」に設定します。
必要に応じ3Dワールドで「PathFrame_1」を選択し右クリックで削除します。
ワークを生成するためプロセスモデリングの動作を追加する必要があります。
ビヘイビアをクリックし、プロセスモデルの中から製品クリエイターを選択します。
製品を生成するための動作を追加します。
コンポーネントグラフにある「ProductCreator」を展開し、インプットとアウトプットを確認します。
「Output」は「Path」の「Input」と接続します。
「ProductCreator」の「Output」を選択し[プロパティ]パネルで[接続]を「Path」に設定します。
[ポート]は「Path」の「Input」と接続するため「Input」を設定します。
「ProductCreator」で生成したものは全て「Path」に流れます。
作業内容を保存するため[コンポーネントの保存]をクリックします。
必要な情報をファイルに追加することができます。
コンピューターに保存するため操作を続行します。
コンポーネントを保存しました。
他のコンポーネントを準備し動作を確認します。
[ホーム]タブに移動します。
eカタログの[タイプ別モデル]から[Conveyors]を展開し[Visual Components]をクリックします。
Conveyorを3Dワールドにドラッグします。
PnPを使用しコンベアをフィーダーに近づけることで、緑色の矢印が表示されます。
コンベアをフィーダーに接続し三角形が緑色に変化したことを確認します。
シミュレーションを再生します。
コンポーネントクリエーターに生成するワークを設定していないため生成されません。
ワークを定義します。
シミュレーションをリセットし3Dワールドにワークに使用するコンポーネントを追加します。
eカタログの[タイプ別モデル]の[Basic Shapes]をクリックし、Block Geo、Conical Tube Geometry、Cylinder Geoを追加します。
[プロセス]タブに移動します。
[エディタ]グループの[製品]をクリックし[製品タイプエディタ]を表示します。
ワークを移動するためのフローグループと製品タイプがないため製品タイプを追加します。
フローグループが自動的に作成されます。
製品タイプを3つ作成します。
製品タイプ1を右クリックすることで名前を変更することができます。
名前を「Block」に変更します。
「Block」を選択した状態でプロパティに移動し、3Dワールドにあるブロックコンポーネントを製品の参照として定義します。
選択ボタンをクリックします。
3Dワールドでブロックを選択し製品タイプに関連付けます。
ブロックは必要ないため選択し削除します。
必要に応じコンポーネントからプロパティを取得することができます。
製品タイプを展開しコンポーネントプロパティを選択します。
右クリックしコンポーネントプロパティを追加を選択することで、削除したブロックからプロパティを追加することができます。
LengthX、WidthY、HeightZ、マテリアルがありますが、マテリアルを選択します。
白が設定されています。
透明感のある色を設定します。
transp_orangeは透明感のあるオレンジです。
transp_blueは透明感のある青です。
transp_blueを選択します。
製品タイプ2の名前を変更するため右クリックします。
「Cone」に変更します。
「Cone」を選択した状態でコンポーネントURIプロパティを設定します。
選択ボタンをクリックし3Dワールドで コーンを選択します。
コーンは必要ないため、選択し削除します。
製品タイプ3を選択し[プロパティ]パネルで名前を「Cylinder」に変更します。
コンポーネントURIを選択します。
シリンダーは必要ないため削除します。
シミュレーションを再生します。
コンポーネントクリエーターにワークを生成する指示を出していないため何も生成されません。
シミュレーションをリセットします 。
フィーダーを選択します。
コンポーネントプロパティには[ProductCreator]タブがありコンポーネントクリエイターに生成するものを定義します。
[フィードモード]は「単一」に設定されており一度に一つの製品を生成します。
「バッチ」はExcelのような表を設定します。
分布、疑似乱数、定数値を設定することもできます。
すべてのフィードモードの使用方法を説明します。
「単一」の場合、製品を生成する頻度の間隔と生成する製品の最大個数を設定します。
[パーツプーリング]はコンピューター内のメモリーの量を制限、リソースを再利用する場合に使用しますが、今回は使用しません。
生成する製品を設定するため「Block」を選択します。
5秒ごとに「Block」を生成します。
シミュレーションを再生します。
透明な青いボックスが生成されました。
5秒ごとに生成しています。
シミュレーションをリセットします。
「Block」のマテリアルを変更します。
「titanium」を選択します。
シミュレーションを再生しマテリアルの変更が反映されていることを確認します。
シミュレーションをリセットしフィーダーを選択します。
生成する製品を「Cone」に変更します。
シミュレーションを再生し「Cone」を生成しました。
リセットし製品タイプを「Cylinder」に変更します。
シミュレーションを再生します。
「Cylinder」を生成しました。
「単一」の設定は以上です。
次に「バッチ」を設定します。
表を作成します。
表のプロダクトに「Block」、「Cone」、「Cylinder」を追加します。
3種類の製品を一つずつ生成するため[Count]を「1」に設定します。
[バッチ間隔]は、「Block」をカウントの個数分生成し、次の「Cone」、「Cylinder」、再度「Block」を生成するまでの時間のことです。
[バッチ間隔]を10秒に設定します。
「Block」を一つ生成し次に10秒待機後「Cone」を生成します。
10秒待機後「Cylinder」を生成し10秒待機したら最初の「Block」に戻ります。
シミュレーションを再生します。
シミュレーションをリセットします。
表に戻り「Block」の[Count]を「3」に、[Interval]を「5」に設定します。
5秒ごとに「Block」を3つ生成し10秒待機後「Cone」を作成します。
10秒待機し「Cylinder」を生成し10秒待機後「Block」を生成します。
このように生成するワーク個数、同じワークを生成する間隔、別のワークを生成し始める間隔を[ProductCreator]で定義することができます。
「バッチ」の設定は以上です。
次に「分布」を設定します。
使用するものは疑似乱数または正規分布ではなく荷重確率です。
表の[Product]に「Block」と「Cylinder」を追加します。
[間隔]を10秒に変更します。
定数値を設定しましたが[間隔]の+ボタンをクリックすることで、正規分布または一様分布を設定することもできます。
[Probability]は合計2になるため2つの製品を生成します。
生成するワークは表にある2種類のため生成される可能性は50%ずつです。
シミュレーションを再生します。
「Block」を生成し10秒後「Cylinder」を生成しました。
シミュレーションをリセットし、必要に応じ「Block」の[Probaility]を「2」に変更することができます。
[Probability]は 合計3になりました。
シミュレーションを再生します 。
「Block」は「Cylinder」より高確率で生成されます。
「Block」の[Probability]を「5」に変更し、「Cylinder」は「3」に変更します。
[Probability]は合計8になりました。
シミュレーションを再生します。
「Block」を生成する可能性が高いですが「Cylinder」を生成します。
約30秒後「Cylinder」を生成しました。
Probabilityは生成する製品の個数ではなく、Probabilityの合計から製品を生成する確率です。
生成する製品に「Cone」を追加し、Probabilityを9に設定します。
「Block」、「Cylinder」、「Cone」を生成します。
「Cone」を生成する確率が一番高い設定です。
シミュレーションをリセットします。
次に[フィードモード]を「表」に設定します。
ファイルではコンマ区切り形式またはxls形式のExcelファイルを読み込むことができます。
必要に応じ大量のデータをExcelファイルに入れ、ファイルをインポートし、生成する製品と製品を生成するシミュレーション中の時間を定義します。
Excelを開きます。
最初に生成する製品と時間を入力します。
時間はシミュレーション時間です。
生成する製品を確認します。
「Block」、「Cone」、「Cylinder」とあります。
Excelに「Block」、「Cone」、「Cylinder」の順番で入力します。
シミュレーション時間を入力します。
「Block」は10秒、「Cone」に2秒と入力する場合、機能しません。
シミュレーション時間を入力するため10秒の2秒後は12秒と入力する必要があります。
「Cylinder」は20秒に設定します。
ファイルをxls形式で保存します。
ファイル名を「MyOrder.xls」にし保存します。
インポート時ファイルを開くことができないためファイルを閉じる必要があります。
ファイルを閉じます。
ファイルを設定します。
ファイルのURIを設定するためファイルエクスプローラーから読み込みます。
Excelファイルを設定することで表が作成されました。
表を編集することはできないためExcelファイルを直接編集する必要があります。
シミュレーション中10秒時点で「Block」を生成し、12秒で「Cone」を、20秒で「Cylinder」を生成します。
エラーが発生した場合に備え[出力]ウィンドウをクリアします。
シミュレーションを再生します。
10秒経過後「Block」を生成し12秒で「Cone」を生成しました。
20秒経過後「Cylinder」を生成しました。
「表」モードではループせず、読み込んだファイルに基づきワークを生成します。
ループが必要な場合、バッチ、単一、分布のいずれかを使用します。
表を編集するためExcelに戻ります。
3種類の製品を100個生成するため、製品名をコピーし貼り付けます。
シミュレーション時間も設定します。
100までドラッグしマウスボタンを離します。
時間を設定することができました。
約500秒で100個の製品を生成します。
Excelファイルを保存し閉じます。
Excelファイルを再度読み込みます。
表の製品と時間が更新されました。
更新が表示されない場合製品を定義を クリックしExcelファイルを再度読み込みます。
シミュレーションを再生します。
10秒後にワークを生成します。
シミュレーション時間は504秒です。
シミュレーション速度を上げます。
約9分後製品の生成が終わりました。
シミュレーションを一時停止します。
[モデリング]タブに移動しコンポーネントを保存します。
コンポーネントの変更を保存し[ホーム]タブに移動します。
フィーダーを削除します。
フィーダーを3Dワールドに再度追加します。
フィーダーはマイモデルに保存したため3Dワールドに追加します。
フィーダーをコンベアに接続します。
表とデータはコンポーネントと一緒に保存されています。
[プロセス]タブに移動し製品タイプを確認します。
コンポーネントと一緒に保存されています。
シミュレーションを再生します。
10秒後、製品を生成しました。
シミュレーションをリセットします。
フィードモードをバッチに変更します。
バッチの設定があります。
最初にブロックを生成し、10秒後コーンを生成しました。
フィーダーをモデリングする方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

プッシャーで複数のワークを同時に押し出してみよう(1/3)

複数のワークを同時に押し出せる、オリジナルのプッシャーを作る方法（3DCADファイルをインポート、可動部を分割、機構付け）
https://youtu.be/HjMTMXSdXog
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_120_p1.zip

プッシャーで複数のワークを同時に押し出す方法について説明します。
設定が完了すると、プッシャーで複数のワークを同時に押し出すことができます。
本動画では、プッシャーのCADファイルをインポートし、可動部を設定します。
[Works_before.vcmx]を開きます。
3つのワークと、設定済みのコンベアが表示されます。
CADファイルをインポートします。
[ホーム]タブ、または[モデリング]タブをクリックします。
[インポート]グループの[ジオメトリ]をクリックすることで、CADファイルをインポートできます。
[Pusher.step]を選択し、[開く]をクリックします。
[モデルをインポート]ウィンドウでは、インポート時のプロパティを設定できます。
[構造]は、モデルを分割する方法を設定できます。
[フィーチャ]は、分割せず、[ノード]は、ジオメトリをすべて別のノードに分割します。
[コンポーネント]は、ジオメトリをすべて別のコンポーネントに分割します。
単一のモデルをインポートする場合、[フィーチャ]か[ノード]を選択します。
レイアウトをインポートする場合、[コンポーネント]を選択します。
[Pusher.step]は、単一のモデルとしてインポートするため、[フィーチャ]を選択します。
3Dワールドに表示されるモデルは、多数の三角形で構成されており、[テッセレーションの品質]は、三角形の個数を設定できます。
モデルのデータ量に応じて品質を変更します。
低品質にすることで、モデルのデータ量を削減できます。
今回のモデルは、データ量が少ないため、[中位品質]に設定します。
[含める]では、インポート時のジオメトリに含む要素を設定できます。
今回は、[マークアップ]と[マテリアル]と[テクスチャー]を選択します。
[マテリアル作成ルール]では、マテリアルライブラリを作成するためのルールを設定できます。
今回は、[常にライブラリから最も近似のものを使用します]を選択します。
[フィーチャツリー]は、フィーチャツリーの作成方法を、設定できます。
[完全]は、トランスフォームフィーチャを使用し、CADファイルと階層構造を完全に一致させます。
[最適化]は、すべてのジオメトリを同じ階層にし、[最小化]は、ジオメトリを1つにまとめることができます。
プッシャーに可動部を設定するため、フィーチャツリーをシンプルな状態にします。
[最適化]を選択します。
[ジオメトリを整理]では、ジオメトリセットを作成するためのルールを設定できます。
ジオメトリセットは、フィーチャツリーの各ジオメトリの中に含まれるジオメトリのまとまりです。
メッシュを構成する三角ポリゴンの3点の合計が10000を超えると、新しいジオメトリセットが作成されます。
[面による]は、面ごとに、[マテリアルによる]は、マテリアルごとにジオメトリセットを作成できます。
[折りたたみ]は、ジオメトリセットを1つにまとめ、[数学的データ]は、曲線のジオメトリセットを作成できます。
今回は、[マテリアルによる]を選択します。
[上軸]は、ジオメトリの上面と底面を整列させる軸を設定できます。
[上軸]で[+Z]を選択し、[インポート]をクリックします。
3Dワールドに、プッシャーをインポートできたことがわかります。
プッシャーが、3Dワールドの原点に配置されない場合、[コンポーネントプロパティ]ウィンドウの[座標]をすべて0に変更します。
プッシャーに可動部を設定するため、[モデリング]タブを開きます。
プッシャーの青い部分を選択します。
右クリックして、メニューを開きます。
[抽出]から[抽出リンク]を選択することで、選択したジオメトリを新しいノードへ抽出できます。
[コンポーネントグラフ]ウィンドウに、「Link_1」が追加されたことがわかります。
Link_1に動作の詳細を設定します。
[リンクプロパティ]ウィンドウで、[JointType]を設定することで、動作の種類を定義できます。
[固定]は、動作を設定せず、ノードを定義した位置に固定できます。
[回転]は、定義した軸を中心に回転運動、[直進]は、軸に沿って直線運動できます。
[回転フォロワー]は、別のノードの運動量と連動した回転運動ができます。
[直進フォロワー]も[回転フォロワー]と同様に、別のノードと連動した直線運動です。
[カスタム]は、定義した軸を基準に、回転または直線運動できます。
今回は、[直進]を選択します。
可動部が動作する方向を設定します。
[軸]で+Xを選択します。
[軸]で選択する方向は、3Dワールドではなく、ノード自体の方向です。
[リンクプロパティ]ウィンドウの、[座標]の右側にある[オブジェクト]を選択することで、選択しているノードの方向を確認できます。
可動部が動作する方向を確認します。
[マニピュレーション]グループの[インタラクティブ]を選択することで、可動部の動作を確認できます。
3Dワールドで、「Link_1」をドラッグします。
「Link_1」がX軸方向に動作することがわかります。
シミュレーションのリセットボタンをクリックすることで、可動部が初期位置に戻ります。
[リンクプロパティ]ウィンドウの[Controller]は、ノードの動作を制御するコントローラーを定義できます。
[Controller]をクリックし、「新規サーボコントローラ」を選択します。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]を展開すると、サーボコントローラが追加されていることがわかります。
Geminiのサーボコントローラは、一般的なサーボコントローラとは異なり、可動部を制御する仮想のコントローラーを意味します。
[リンクプロパティ]ウィンドウの[初期値]は、ノードの初期位置、[J1]は、ノードの現在位置を表示しています。
現在、[初期値]と[J1]は0です。
[最小リミット]と[最大リミット]は、ノードが動作できる範囲の最小値と最大値を定義できます。
[最小リミット]と[最大リミット]を空白にすることで、動作できる範囲を制限しないこともできます。
今回は、[最小リミット]を0、[最大リミット]を600に設定します。
3Dワールドで、「Link_1」をドラッグします。
「Link_1」が、[最小リミット]と[最大リミット]の範囲外に動作すると、[リンクプロパティ]ウィンドウの[J1]にエラーが発生します。
範囲外に動作しない設定にする場合、[プログラム]タブをクリックし、[リミット]グループの[リミットで停止]にチェックを付けます。
[モデリング]タブをクリックします。
3Dワールドで、「Link_1」をドラッグします。
「Link_1」は、範囲外に動作しません。
リセットボタンをクリックします。
プッシャーの可動部についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

プッシャーで複数のワークを同時に押し出してみよう(2/3)

複数のワークを同時に押し出せる、オリジナルのプッシャーを作る方法（ワークを検出する干渉ディテクター、格納するコンテナ）
https://youtu.be/kATVHiyI8GI
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_120_p2.zip

プッシャーで複数のワークを同時に押し出す方法について説明します。
本動画では、複数のワークを同時に押し出すために必要な設定をします。
本動画は、プッシャーの可動部を設定する方法の続きから設定します。
プッシャーに可動部が設定されたファイル[Works1_after.vcmx]が必要です。
半透明なブロックを、ワークを検出する範囲として使用するため、別のコンポーネントへ抽出します。
[モデリング]タブを開きます。
半透明なブロックを選択します。
右クリックして、メニューを開きます。
[抽出]から[コンポーネントを抽出]を選択することで、選択したジオメトリを新しいコンポーネントへ抽出できます。
[コンポーネントプロパティ]ウィンドウで、名前をBoxに変更します。
[マニピュレーション]グループの[インタラクティブ]を選択します。
3Dワールドで、「Link_1」をドラッグします。
現在、Boxはプッシャーの可動部に追従しません。
リセットボタンをクリックします。
Boxが、可動部の動作に追従するように設定します。
[ホーム]タブをクリックします。
Boxを選択している状態で、[階層]グループの[アタッチ]を選択します。
[アタッチ]は、選択しているコンポーネントを、別のコンポーネント、またはノードの子階層に設定できます。
子階層のコンポーネントは、親の移動に追従します。
[出力]ウィンドウに、「3Dワールドで、新しい親となるノードをクリックしてください」と表示されます。
3Dワールドで、「Link_1」を選択します。
[出力]ウィンドウに、「Link_1」が、Boxの親となったことが表示されます。
3Dワールドで、「Link_1」をドラッグします。
Boxが、プッシャーの動作に追従することがわかります。
リセットボタンをクリックします。
ワークを検出する範囲を定義するため、干渉チェックを設定します。
[プログラム]タブをクリックします。
[干渉検出]グループから[ディテクターを編集]を選択します。
[干渉ディテクター]ウィンドウで、干渉チェックの詳細を設定できます。
デフォルトでは、[選択対ワールド]という名前の干渉ディテクターが設定されています。
[選択対ワールド]は、現在選択しているコンポーネントと、3Dワールドにあるすべてのコンポーネントの干渉を検出できます。
[選択対ワールド]の右側にあるアイコンをクリックし、干渉ディテクターをオフにします。
新しい干渉ディテクターを追加します。
3Dワールドの何もない場所をクリックし、選択を解除します。
[干渉ディテクター]ウィンドウの、検索ボックスの右側にあるプラスアイコンをクリックし、[干渉ディテクターを追加]を選択します。
新しい干渉ディテクターを追加できます。
[プロパティ]の[干渉を検出]では、記録する干渉について設定できます。
[最初]は、最初に検出した干渉のみ記録します。
[全て]は、検出した干渉をすべて記録します。
今回は、[全て]を選択します。
干渉チェックの対象となるコンポーネントを定義します。
リストAと、リストBに定義されたコンポーネント間の干渉を検出できます。
3Dワールドで、Boxを選択します。
ミニツールバーが表示され、[A]アイコンを選択すると、リストAに、[B]アイコンを選択すると、リストBに追加できます。
今回は、[A]アイコンをクリックします。
[干渉ディテクター]ウィンドウの、リストAにBoxが追加されたことがわかります。
コンポーネントを選択した状態で、[選択を追加]をクリックすることでも、開いているリストに、コンポーネントを追加できます。
リストAのコンポーネントは緑、リストBのコンポーネントは青く表示されます。
[干渉マテリアル]を変更することで、干渉発生時の、コンポーネントの色を変更できます。
リストAのコンポーネントは、色を変更しないため、干渉発生前と同じ[transp_red]を選択します。
リストBを設定するため、タブBをクリックします。
ワークが、シミュレーション開始後に生成される場合もあるため、現時点ではリストBにコンポーネントを追加しません。
シミュレーション開始後、PythonScriptで、リストBにコンポーネントを追加します。
干渉発生時のコンポーネントの色を設定します。
[干渉マテリアル]をクリックし、[blue]を選択します。
リストからコンポーネントを除外する場合、3Dワールドでコンポーネントを選択した時に表示されるミニツールバーか、リストの、コンポーネント名の右側にある[ゴミ箱]アイコンをクリックします。
リストのチェックボックスからチェックを外すことでも、除外することができます。
設定した干渉ディテクターを有効にするため、[干渉検出]グループの[ディテクターを有効にする]にチェックを付けます。
[干渉の停止]は、干渉を検出した場合、シミュレーションを一時停止する機能です。
今回は、一時停止しないため、チェックがついていないことを確認します。
ワークを押し出すため、プッシャーの可動部に、ワークを格納する設定を追加します。
[干渉ディテクター]ウィンドウの[閉じる]をクリックします。
プッシャーを選択し、[モデリング]タブを開きます。
[コンポーネントグラフ]ウィンドウで、「Link_1」を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[マテリアルフロー]から[コンポーネントコンテナ]を選択します。
コンテナは、設定したコンポーネントに、別のコンポーネントを格納できます。
ノードにコンテナを設定することで、可動部の動作に、格納したコンポーネントを追従させることができます。
プッシャーに動作を指示するため、シグナルを追加します。
[コンポーネントグラフ]ウィンドウで、[Pusher]を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[ブール型]を選択します。
ブール型シグナルは、オンオフを通知できます。
[プロパティ]ウィンドウで、名前をPushに変更します。
同様に、もう1つシグナルを追加します。
名前は、Pullです。
複数のワークを同時に押し出すために必要な設定についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

プッシャーで複数のワークを同時に押し出してみよう(3/3)

複数のワークを同時に押し出せる、オリジナルのプッシャーを作る方法（干渉検出したワークを押し出すパイソンスクリプト（Python））
https://youtu.be/rdb_L3SiWl8
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_120_p3.zip

プッシャーで複数のワークを同時に押し出す方法について説明します。
本動画では、複数のワークを同時に押し出すためのPythonScriptを設定します。
本動画は、複数のワークを同時に押し出すために必要な設定の続きから説明します。
押し出すために必要な設定が完了しているファイル[Works2_after.vcmx]が必要です。
検出範囲内のワークを、プッシャーで押し出すため、PythonScriptを追加します。
プッシャーを選択します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
エディタが自動的に開くため、デフォルトで記述されているソースコードを1行目以外削除します。
Boxと干渉しているコンポーネントを、コンテナに格納し、可動部と一緒に動作させます。
パイソンスクリプトを含むコンポーネントの情報を取得するため、comp=getComponent()と記述します。
servo = comp.findBehaviorと記述することで、コンポーネントのビヘイビアを参照できます。
カッコ内にサーボコントローラと記述し、名前を指定します。
シグナルを参照するため、push = comp.findBehaviour("Push")と記述します。
同様に、シグナルPullを参照します。
コンテナを参照するため、cont = comp.findBehaviour("ComponentContainer")と記述します。
干渉チェックリストに、3Dワールドに存在するすべてのコンポーネントを追加します。
すべてのコンポーネントを参照するためには、シミュレーションオブジェクトを取得する必要があります。
sim = getSimulation()と記述します。
搬送先のコンベアに、ワークを格納するため、コンベアのパスを参照する必要があります。
現在記述しているPythonScriptを含むコンポーネント以外のコンポーネントを参照する場合、まずGeminiのアプリケーションにアクセスします。
Geminiのアプリケーションにアクセスするため、app=getApplication()と記述します。
次に、参照するコンポーネントを指定します。
con = app.findComponentと記述することで、別のコンポーネントを参照できます。
カッコ内にConveyorと記述し、名前を指定します。
最後に、コンポーネント内の参照するビヘイビアを指定します。
パスを参照するため、path = con.findBehaviour("OneWayPath")と記述します。
def OnRun():と記述することで、シミュレーション開始時にプログラムを実行できます。
while True:と記述し、以下のプログラムをループさせます。
triggerCondition(lambda:getTrigger()==push or getTrigger()==pull)と記述することで、pushかpullのオンオフが切り替わるまで、以下のプログラムを実行せず、待機できます。
Pushがオンの場合、プログラムを実行するため、if push.Value == True:と記述します。
干渉ディテクターを参照し、リストBに、3Dワールドに存在するすべてのノードを追加します。
dt = app.findLayoutItem("干渉ディテクター#1")と記述することで、干渉ディテクターを参照できます。
dt.NodeListB = [(sim.World,VC_NODELIST_INCLUDE,VC_NODELIST_TREE)]と記述し、リストBに、3Dワールドに存在するすべてのノードを追加します。
カッコ内の1番目は、リストに追加するノードを定義します。
sim.Worldは、3Dワールドです。
カッコ内の2番目では、干渉の有効化、または無効化を定義します。
VC_NODELIST_INCLUDEは、干渉の有効化を示しています。
カッコ内の3番目では、ノードの意味を定義します。
VC_NODELIST_TREEは、ノードが、子階層のノードを含むことを意味します。
3Dワールドの、子階層に存在するすべてのノードが、リストBに追加されます。
干渉を検出した回数、コンテナにワークを格納します。
干渉を検出した数を取得するため、count = dt.HitCountと記述します。
countが0より大きい間、干渉を検出したワークをプッシャーに格納するため、while count > 0:と記述します。
work= dt.getHitNodeB().Componentと記述することで、リストBから干渉を検出したものをピックアップできます。
カッコ内に、count-1と記述することで、リスト内での番地を指定できます。
ワークをコンテナに格納するため、cont.grab(work)と記述します。
count=count-1と記述し、現在のリストの番地から1引きます。
コンポーネントの格納後、プッシャーの可動部を移動させます。
インデントを1つ下げるため、シフトキーとタブキーを同時に押します。
可動部を移動させるため、servo.moveJoint(0,600)と記述します。
moveJointは、サーボコントローラで制御されたノードを、移動させることができます。
カッコ内の0は、サーボコントローラに定義されているノードリストの0番目を表します。
600は、ノードが移動する目標位置です。
プッシャーの可動部が移動した後、ワークをコンベアに流すため、干渉を検出した数を取得します。
count2 = dt.HitCountと記述します。
count2が0より大きい間、干渉を検出したワークをコンベアに流すため、while count2 > 0:と記述します。
work = dt.getHitNodeB(count2 - 1).Componentと記述し、リストBから干渉を検出したものをピックアップします。
path.grab(work)と記述し、ワークをコンベアのパスに格納します。
count2=count2 - 1と記述し、現在のリストの番地から1引きます。
Pullがオンの場合、プログラムを実行するため、elif pull.Value == True:と記述します。
プッシャーの可動部を初期位置に戻します。
servo.moveJoint(0,0)と記述します。
Pythonスクリプトエディタ左上の[コンパイル]をクリックします。
先程、PythonScriptに記述したtriggerConditionで、PushとPullをトリガーとして使用するため、接続します。
[コンポーネントグラフ]ウィンドウで、Pushを選択します。
[プロパティ]ウィンドウで、[接続]をクリックすることで、プラスアイコンが表示されます。
プラスアイコンをクリックし、表示される[Add Connections items]ウィンドウで、PythonScriptを選択します。
[Add Connections items]ウィンドウを閉じます。
同様に、PullとPythonScriptを接続します。
干渉ディテクターは、Geminiを起動する度に無効化されるため、確認します。
[プログラム]タブを開きます。
[干渉検出]グループの、[ディテクターを有効にする]にチェックがついていることを確認します。
干渉を検出した時、シミュレーションを一時停止しないため、[干渉の停止]にチェックがついていないことを確認します。
シミュレーションを実行します。
プッシャーを選択します。
[接続]グループの[シグナル]を選択することで、シグナルエディタを表示できます。
Pushの右側にある丸をクリックします。
Pushがオンになり、プッシャーが3つのワークを押し出すことがわかります。
押し出されたワークはコンベアを流れ、端まで移動すると、消失します。
Pushをオフにし、Pullをオンにします。
プッシャーが元の位置に戻ることがわかります。
Pushをオンにする前後で、干渉ディテクターのリストBが、どのように変化したかを確認します。
シミュレーションをリセットします。
[干渉検出]グループの[ディテクターを編集]をクリックします。
[干渉ディテクター]ウィンドウで、[干渉ディテクター#1]を選択します。
[プロパティ]のリストBを表示すると、ROOTが追加されています。
ROOTは、3Dワールドのことです。
PythonScriptで、リストBに追加する時、ノードの定義を子階層を含むものとしたため、リストBには、3Dワールドに存在するすべてのノードが追加されています。
プッシャーで複数のワークを同時に押し出す方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

プッシャーを作ってみよう(1/4)

製品を押し出せる、プッシャーの可動部の機構設定方法
https://youtu.be/cFLcHjsa9jQ
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_063_p1.zip

プッシャーの可動部の設定方法について説明します。
CADファイルをインポートします。
[ホーム]タブを選択し、[インポート]グループの[ジオメトリ]をクリックすることで、CADファイルをインポートすることができます。
[Pusher.3ds]を選択し、[開く]をクリックします。
[モデルをインポート]ウィンドウでは、インポート時のプロパティを設定することができます。
[構造]は、単一のモデルをインポートする場合、[フィーチャ]か[ノード]を選択します。
レイアウトをインポートする場合、[コンポーネント]を選択します。
今回は、[フィーチャ]を選択します。
3Dワールドに表示されるモデルは、多数の三角形で構成されており、[テッセレーションの品質]は、三角形の個数を設定することができます。
データ量の多いモデルの場合、低品質にすることで、データ量を削減することができます。
今回はデータ量が少ないため、[中位品質]に設定します。
[含める]では、インポートするとき、ジオメトリに含む要素を設定することができます。
[マークアップ]と[マテリアル]と[テクスチャー]を選択します。
[マテリアル作成ルール]では、マテリアルライブラリを作成するためのルールを設定することができます。
[常にライブラリから最も近似のものを使用します]を選択します。
[フィーチャツリー]は、フィーチャツリーの作成方法を、設定することができます。
[完全]は、CADファイルの階層構造をベースにし、すべてのジオメトリをトランスフォームフィーチャに入れ、フィーチャツリーを作成します。
CADファイルと完全に階層構造を一致させる場合、[完全]を選択します。
[最適化]は、すべてのジオメトリを同じ階層にし、[最小化]は、ジオメトリを1つにまとめることができます。
プッシャーの可動部を設定するとき、フィーチャツリーをシンプルにするため、[最適化]を選択します。
[ジオメトリを整理]では、ジオメトリセットを作成するルールを設定することができます。
ジオメトリセットは、フィーチャツリーの各ジオメトリの中に含まれるジオメトリのまとまりです。
メッシュを構成する三角ポリゴンの3点の合計が10000を超えると、新しいジオメトリセットが作成されます。
面ごとにジオメトリセットを作成する場合、[面による]を、マテリアルごとの場合、[マテリアルによる]を選択します。
ジオメトリセットを1つにまとめる場合、[折りたたみ]を、曲線のジオメトリセットを作成する場合、[数学的データ]を選択します。
今回は、[マテリアルによる]を選択します。
[上軸]は、ジオメトリの上面と底面を整列させる軸を設定することができます。
[上軸]で[-X]を選択し、[インポート]をクリックします。
プッシャー、ワークおよびテーブルのCADファイルをインポートすることができます。
ワークを、プッシャーとは別のコンポーネントに分けるため、[モデリング]タブを開きます。
赤いブロックをワークAとします。
3Dワールドで、ワークAを選択します。
右クリックして、メニューを開きます。
[抽出]から[コンポーネントを抽出]を選択することで、選択したジオメトリを新しいコンポーネントに抽出することができます。
コンポーネントの名前を、WorkAに変更します。
同様に、ワークAの下にあるテーブルを別のコンポーネントに分けます。
ワークAの下にあるテーブルをテーブルAとします。
3Dワールドで、テーブルAを選択します。
右クリックしてメニューを開きます。
[抽出]から[コンポーネントを抽出]を選択します。
名前をTableAに変更します。
プッシャーの可動部を設定します。
プッシャーには、Z軸方向に動作し、押し出すときの高さを調整する可動部と、X軸方向に動作し、ワークを押し出す可動部があります。
Z軸方向の可動部を設定します。
プッシャーの灰色の部分をすべて選択します。
コントロールキーを押した状態で、選択をすることで、複数のジオメトリやコンポーネントを選択することができます。
右クリックして、メニューを開きます。
[抽出]から[抽出リンク]を選択することで、選択したジオメトリを新しいノードに抽出することができます。
[コンポーネントグラフ]ウィンドウに、「Link_1」が追加されたことがわかります。
Link_1に動作の詳細を設定します。
[リンクプロパティ]ウィンドウで[JointType]を設定することで、動作の種類を定義することができます。
固定は、動作は設定せず、ノードを固定することができます。
回転は、定義した軸を中心に回転運動し、直進は、定義した軸に沿って直線運動することができます。
回転フォロワーは、別のノードの運動量に基づき、定義した軸を中心に回転運動し、変換フォロワーは、運動量に基づき、直線運動することができます。
カスタムは、定義した軸を基準に、回転運動か直線運動することができます。
今回は、直進を選択します。
可動部が動作する方向を設定します。
[軸]で-Zを選択します。
可動部が動作する方向を確認します。
[マニピュレーション]グループの[インタラクティブ]を選択することで、可動部の動作を確認することができます。
3Dワールドで「Link_1」をドラッグします。
「Link_1」が、Z軸方向に動作することがわかります。
シミュレーションのリセットボタンをクリックすることで、可動部が初期位置に戻ります。
[リンクプロパティ]ウィンドウの[Controller]は、ノードの動作を制御するコントローラーを定義することができます。
[Controller]をクリックし、「新規サーボコントローラ」を選択します。
[Controller]がサーボコントローラになります。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]を展開すると、サーボコントローラが追加されたことがわかります。
[リンクプロパティ]ウィンドウの[初期値]はノードの初期位置、[J1]はノードの現在位置を表示しています。
現在、[初期値]と[J1]は0です。
[最小リミット]と[最大リミット]は、ノードの可動範囲の最小値と最大値を定義することができます。
[最小リミット]を0、[最大リミット]を50に設定します。
3Dワールドで「Link_1」をドラッグします。
「Link_1」が、[最小リミット]と[最大リミット]の範囲外に動作すると、[リンクプロパティ]ウィンドウの[J1]にエラーが発生します。
範囲外に動作しない設定にする場合、[プログラム]タブをクリックし、[リミット]グループの[リミットで停止]にチェックを付けます。
[モデリング]タブをクリックします。
3Dワールドで、「Link_1」をドラッグします。
範囲外に動作しないことを確認します。
リセットボタンをクリックします。
X軸方向の可動部を設定します。
プッシャーの青い部分を選択します。
右クリックして、メニューを開きます。
[抽出]から[抽出リンク]を選択し、新しいノードに抽出します。
[コンポーネントグラフ]ウィンドウに、「Link_2」が追加されたことがわかります。
Link_2に動作の詳細を設定します。
ワークを押し出す動作を設定します。
[リンクプロパティ]ウィンドウの[JointType]を「直進」、[軸]を「-X」に設定します。
「Link_1」と「Link_2」を、別々のタイミングで動作できるようにするため、「Link_1」と「Link_2」は異なるサーボコントローラを使用します。
[Controller]では「新規サーボコントローラ」を選択します。
[Controller]がサーボコントローラ_2になります。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]に、サーボコントローラ_2が追加されたことがわかります。
「Link_2」の可動範囲を設定するため、[最小リミット]を0、[最大リミット]を290に設定します。
3Dワールドで「Link_2」をドラッグします。
「Link_2」が、X軸方向に動作することがわかります。
3Dワールドで「Link_1」をドラッグします。
「Link_2」は、「Link_1」の動作に追従しないため、「Link_1」の動作に追従するように設定します。
リセットボタンをクリックします。
[コンポーネントグラフ]ウィンドウの「Link_2」をシフトキーを押した状態で、ドラッグ＆ドロップし、Link_1に入れます。
新しいノードを追加するとき、[コンポーネントグラフ]ウィンドウの「Link_1」を選択した状態で、[構造]グループの[リンクをクリエイト]をクリックすることで、自動的に「Link_1」の子階層に入れることもできます。
3Dワールドで「Link_1」をドラッグします。
「Link_2」は「Link_1」の動作に追従することがわかります。
リセットボタンをクリックします。
プッシャーの可動部の設定方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

プッシャーを作ってみよう(2/4)

プッシャーが製品を検知するセンサーの設定方法
https://youtu.be/8f5Clgd0EHk
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_063_p2.zip

プッシャーで、ワークを押し出すために必要な設定について説明します。
本動画は、プッシャーの可動部の設定方法の続きから設定します。
プッシャーの可動部の設定が完了しているファイル[Pusher1_after.vcmx]が必要です。
ワークを押し出すためには、プッシャーと押し出す先にコンテナを設定し、ワークをコンテナからコンテナへ格納する必要があります。
コンテナは、コンポーネントに別のコンポーネントを格納することができます。
ワークは「Link_2」の動作に連動して押し出されるため、[コンポーネントグラフ]ウィンドウで「Link_2」を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[マテリアルフロー]から[コンポーネントコンテナ]を選択します。
同様に、テーブルAにコンテナを設定します。
3DワールドでテーブルAをダブルクリックすることで、テーブルAのコンポーネントを選択することができます。
[動作設定]グループの[ビヘイビア]を展開し、[マテリアルフロー]から[コンポーネントコンテナ]を選択します。
ワークを押し出すプログラムを、パイソンスクリプトに記述します。
今回は、シミュレーション開始前からワークを配置していますが、シミュレーション開始後にワークを生成する場合もあります。
ワーク生成時にランダムな名前が付与されるため、ワークの情報を取得する必要があります。
ワークの情報を取得するため、ワークを検出するセンサーを設定します。
センサーの位置を設定します。
センサーの位置は、プッシャーの「Link_1」と「Link_2」の動作に連動して移動するため、プッシャーの青い部分をダブルクリックします。
[コンポーネントグラフ]ウィンドウの、「Link_2」が選択されたことがわかります。
[ジオメトリ]グループの[フィーチャ]を展開し、[その他]から[フレーム]を選択します。
フレームは、3Dワールド上で、位置と方向を定義する基準点です。
3Dワールドに、フレームが表示されない場合、3Dワールドツールバーのフレームタイプを開き、フレームにチェックを付けます。
3Dワールドにフレームを表示することができます。
フレームを移動させるため、[ツール]グループの[スナップ]を選択します。
3Dワールドで、プッシャーの青い部分の中心をクリックします。
センサーで検出したワークの情報を格納するため、シグナルを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[コンポーネント]を選択します。
コンポーネントシグナルは、コンポーネントを値として送受信することができます。
ワークを検出するため、センサーを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[センサー]から[レイキャスト]を選択します。
レイキャストセンサーは、定義したフレームの位置から光線を照射し、光線と交差したコンポーネントを検出することができます。
センサーの位置を、フレームを選択して、定義します。
[プロパティ]ウィンドウの[フレーム]をクリックし、フレームを選択することで、フレームの+Z軸方向に光線を照射することができます。
表示する光線の長さと、ワークを検出する範囲を設定します。
[最大範囲]は、3Dワールドに表示する光線の長さを設定し、[検出しきい値]は、コンポーネントを検出する範囲を設定することができます。
[最大範囲]と[検出しきい値]を30に変更します。
光線を非表示にするときは[光線表示]のチェックを外し、光線を表示するときは[光線表示]にチェックを付けます。
今回は、[光線表示]にチェックを付けます。
[コンポーネントシグナル]は、検出したコンポーネントを値として格納するシグナルを定義します。
[コンポーネントシグナル]でComponentSignalを選択します。
プッシャーの動作するタイミングを指示するため、シグナルを追加します。
[コンポーネントグラフ]ウィンドウで[Pusher]を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[ブール型]を選択します。
ブール型シグナルは、オンオフを送受信することができます。
名前をUpに変更します。
同様に、ブール型シグナルを3つ追加します。
名前は、Down、PositionA、PositionBです。
Upがオンのとき、「Link_1」は0の位置、Downがオンのとき、「Link_1」は50の位置に移動します。
PositionAがオンのとき、「Link_2」は0の位置、PositionBがオンのとき、「Link_2」は100の位置に移動します。
プッシャーの動作完了を通知するため、プロパティを追加します。
[プロパティ]グループの[プロパティ]を展開し、[ベーシック]から[ブール型]を選択します。
プロパティは、コンポーネントのグローバル変数であり、プログラム内のどこからでも使用することができます。
名前をX1に変更します。
同様に、ブール型プロパティを3つ追加します。
名前は、X2、X3、X4です。
X1はUpの動作、X2はDownの動作、X3はPositionAの動作、X4はPositionBの動作が完了したとき、オンになります。
本動画では、X1からX4の各状態を判別し、使用することはありません。
PLCと連携し、ラダー回路でプッシャーの動作を制御する時に使用するため、参考としてX1からX4を追加しています。
プッシャーで、ワークを押し出すために必要な設定についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

プッシャーを作ってみよう(3/4)

プッシャーで製品を押し出すパイソンスクリプト（Python）の設定方法
https://youtu.be/4o411c9iiyM
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_063_p3.zip

プッシャーでワークを押し出すとき、パイソンスクリプトで制御する方法について説明します。
本動画は、プッシャーでワークを押し出すために必要な設定の、続きから設定します。
プッシャーでワークを押し出すために必要な設定が、完了しているファイル[Pusher2_after.vcmx]が必要です。
パイソンスクリプトを追加し、プッシャーが動作するプログラムを記述します。
プッシャーがZ軸方向に動作するためのパイソンスクリプトを追加するため、[コンポーネントグラフ]ウィンドウで「Link_1」を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
エディタが自動的に開くため、デフォルトで記述されているソースコードを1行目以外削除します。
パイソンスクリプトを含むコンポーネントの情報を取得するため、comp=getComponent()と記述します。
servo=comp.findBehaviourと記述することで、コンポーネントのビヘイビアを参照することができます。
カッコ内にサーボコントローラと記述し、名前を指定します。
シグナルを参照するため、up=comp.findBehaviour("Up")と記述します。
同様に、ビヘイビアのDownを参照します。
変数名は、downです。
X1a=comp.getPropertyと記述することで、コンポーネントのプロパティを参照することができます。
カッコ内にX1と記述し、名前を指定します。
同様に、プロパティのX2を参照します。
変数名は、X2aです。
def OnRun():と記述することで、シミュレーションの開始時にプログラムを実行することができます。
プッシャーの初期状態と、プロパティの値を一致させるため、プロパティに初期値を設定します。
シミュレーション開始時、「Link_1」は0の位置にあるため、X1aをTrue、X2aをFalseに設定します。
while True:と記述し、以下のプログラムをループさせます。
triggerCondition(lambda:getTrigger()==up or getTrigger()==down)と記述することで、upかdownのオンオフが切り替わるまで、以下のプログラムを実行せず、待機することができます。
upがTrueの場合、「Link_1」を0の位置に移動します。
X2a.Value=Falseと記述し、「Link_1」が50の位置にあることを示すX2をオフにします。
「Link_1」を0の位置に移動するため、servo.moveJoint(0,0)と記述します。
カッコ内の最初の0は、サーボコントローラに定義されているノードリストの0番目を表しています。
2つ目の0は、ノードが移動する目標位置です。
X1a.Value=Trueと記述し、「Link_1」が0の位置に移動完了したことを示します。
downがTrueの場合、「Link_1」を50の位置に移動します。
X1a.Value=Falseと記述し、「Link_1」が0の位置にあることを示すX1をオフにします。
「Link_1」を50の位置に移動するため、servo.moveJoint(0,50)と記述します。
X2a.Value=Trueと記述し、「Link_1」が50の位置に移動完了したことを示します。
コンパイルをクリックします。
先程PythonScriptに記述したtriggerConditionでUpとDownをトリガーとして使用するため、接続します。
[コンポーネントグラフ]ウィンドウのUpを選択します。
[プロパティ]ウィンドウの[接続]をクリックし、PythonScriptを選択します。
同様に、DownとPythonScriptを接続します。
プッシャーがX軸方向に動作するためのパイソンスクリプトを追加するため、[コンポーネントグラフ]ウィンドウで「Link_2」を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
PythonScript_2のプログラム内容は、PythonScriptと類似しているため、PythonScriptのプログラムをすべて選択し、コピーします。
PythonScript_2のプログラムをすべて選択し、貼り付けます。
PythonScript_2を編集します。
4行目で参照しているサーボコントローラの名前を、「サーボコントローラ_2」に変更します。
5行目の変数名をposAに、参照しているシグナルの名前を、PositionAに変更します。
6行目の変数名をposBに、参照しているシグナルの名前を、PositionBに変更します。
7行目の変数名をX3aに、参照しているプロパティの名前を、X3に変更します。
8行目の変数名をX4aに、参照しているプロパティの名前を、X4に変更します。
ワークの情報を取得するため、センサーで検出したコンポーネントを格納するシグナルを参照します。
signal=comp.findBehaviour("ComponentSignal")と記述します。
「Link_2」が移動するとき、ワークを追従させるため、コンテナを参照します。
cont=comp.findBehaviour("ComponentContainer")と記述します。
押し出し先のテーブルAのコンテナに、ワークを格納するため、テーブルAを参照する必要があります。
パイソンスクリプトを含むコンポーネント以外のコンポーネントを参照する場合、まずGeminiのアプリケーションにアクセスします。
Geminiのアプリケーションにアクセスするため、app=getApplication()と記述します。
次に、参照するコンポーネントを指定します。
テーブルAを参照するため、tableA=app.findComponent("TableA")と記述します。
最後に、コンポーネント内の参照するビヘイビアを指定します。
コンテナを参照するため、cont2=tableA.findBehaviour("ComponentContainer")と記述します。
プロパティの初期値を設定します。
シミュレーション開始時、「Link_2」が0の位置にあるため、X3aをTrue、X4aをFalseに設定します。
triggerConditionでトリガーとして使用するシグナルを、posAとposBに変更します。
posAがTrueの場合、「Link_2」を0の位置に移動します。
X4aをFalseに設定することで、「Link_2」が100の位置にないことを示します。
servo.moveJointで、「Link_2」を0の位置に移動します。
X3aをTrueに設定することで、「Link_2」が0の位置に移動完了したことを示します。
posBがTrueの場合、「Link_2」を100の位置に移動します。
X3aをFalseに設定することで、「Link_2」が0の位置にないことを示します。
センサーで検出したコンポーネントをワークAとして定義します。
ComponentSignalの値に検出したコンポーネントが格納されているため、workA=signal.Valueと記述します。
ワークAをプッシャーのコンテナに格納します。
grabメソッドを使用することで、コンテナやパスにコンポーネントを格納することができます。
cont.grab(workA)と記述します。
「Link_2」の押し出し位置は、100のため、servo.moveJoint(0,100)に変更します。
「Link_2」が移動後にワークAを、テーブルAのコンテナに格納するため、cont2.grab(workA)と記述します。
X4aをTrueに設定することで、「Link_2」が100の位置に移動完了したことを示します。
コンパイルをクリックします。
PythonScript_2に記述したTriggerConditionでPositionAとPositionBをトリガーとして使用するため、接続します。
[コンポーネントグラフ]ウィンドウでPositionAを選択します。
[プロパティ]ウィンドウの[接続]でPythonScript_2を選択します。
同様に、PositionBとPythonScript_2を接続します。
シミュレーションを実行します。
[接続]グループの[シグナル]をクリックし、プッシャーを選択することで、シグナルエディタを表示します。
Downをクリックしてオンにします。
プッシャーが-Z軸方向に動作します。
PositionBをクリックしてオンにします。
プッシャーがワークAを押し出したことがわかります。
PositionBをクリックしてオフにします。
PositionAをクリックしてオンにします。
ワークAは、押し出す前の位置に動作するプッシャーに追従していないため、テーブルAに格納されていることがわかります。
プッシャーでワークを押し出すとき、パイソンスクリプトで制御する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

プッシャーを作ってみよう(4/4)

プッシャーが押し出した製品同士を結合する方法
https://youtu.be/ijCazW6nQnQ
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_063_p4.zip

プッシャーでワーク同士を結合する方法について説明します。
本動画は、プッシャーでワークを押し出すパイソンスクリプトの続きから設定します。
プッシャーでワークを押し出すパイソンスクリプトの設定が、完了しているファイル[Pusher3_after.vcmx]が必要です。
茶色の箱をワークB、箱の下にあるテーブルとセンサーモデルをテーブルBとします。
センサーで検出したワークBのコンテナにワークAを格納することで、ワーク同士を結合します。
ワークBを、プッシャーとは別のコンポーネントに分けます。
コントロールキーを押した状態で、ワークBのジオメトリをすべて選択します。
右クリックして、メニューを開きます。
[抽出]から[コンポーネントを抽出]を選択します。
名前をWorkBに変更します。
同様に、テーブルBを別のコンポーネントに分けます。
コントロールキーを押した状態で、テーブルBのジオメトリをすべて選択します。
右クリックして、メニューを開きます。
[抽出]から[コンポーネントを抽出]を選択します。
名前をTableBに変更します。
ワークAとワークBを結合するため、コンテナを設定します。
ワークBを選択します。
[動作設定]グループの[ビヘイビア]を展開し、[マテリアルフロー]から[コンポーネントコンテナ]を選択します。
ワークBを検出するセンサーの位置を設定します。
センサーモデルを見やすくするため、ワークBを一旦非表示にします。
[コンポーネントグラフ]ウィンドウのWorkBを選択します。
[コンポーネントプロパティ]ウィンドウの[表示]からチェックを外すことで、コンポーネントを非表示にすることができます。
テーブルBをダブルクリックして、コンポーネントを選択します。
[ジオメトリ]グループの[フィーチャ]を展開し、[その他]から[フレーム]を選択します。
フレームをセンサーモデルの位置に移動します。
[ツール]グループから[スナップ]を選択し、センサーモデルの円形部品の中心をクリックします。
非表示にしたワークBを、再び表示します。
[ホーム]タブをクリックします。
[セルグラフ]ウィンドウで、WorkBの目玉アイコンをクリックすることで、コンポーネントを表示することができます。
センサーで検出したワークBの情報を格納するため、シグナルを追加します。
テーブルBを選択し、[モデリング]タブをクリックします。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[コンポーネント]を選択します。
テーブルBにワークがあるか確認するため、ワークの検出を通知するシグナルを追加します。
シグナルのオンオフでワークの有無を通知します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[ブール型]を選択します。
本動画では、BooleanSignalの状態を判別し、使用することはありません。
PLCと連携し、ラダー回路でプッシャーの動作を制御するときに使用するため、参考としてBooleanSignalを追加しています。
ワークBを検出するため、センサーを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[センサー]から[レイキャスト]を選択します。
センサーの位置を、フレームを選択して、定義します。
[プロパティ]ウィンドウの[フレーム]をクリックし、フレームを選択します。
表示する光線の長さと、ワークBを検出する範囲を設定します。
[最大範囲]と[検出しきい値]を15に変更します。
検出したワークBの情報を格納するシグナルを設定します。
[コンポーネントシグナル]でComponentSignalを選択します。
センサーがコンポーネントを検出しているか、通知するシグナルを定義します。
[ブールシグナル]でBooleanSignalを選択することで、コンポーネントを検出したとき、BooleanSignalがオンに、検出していないとき、BooleanSignalがオフになります。
ワーク同士を結合するため、ワークを押し出すパイソンスクリプトを編集します。
プッシャーを選択します。
[コンポーネントグラフ]ウィンドウでPythonScript_2を開きます。
変数を定義します。
ワークBの情報を取得するため、センサーが設定されているテーブルBを参照する必要があります。
参照するコンポーネントを、TableAからTableBに変更します。
変数名もtableBに変更します。
テーブルAのコンテナを参照する記述を削除します。
ワークBの情報を取得するため、センサーで検出したコンポーネントを格納するシグナルを参照します。
signal2=tableB.findBehaviour("ComponentSignal")と記述します。
posBがTrueのとき、ワークAをプッシャーのコンテナに格納し、「Link_2」を190の位置に移動して、ワークAをワークBのコンテナに格納します。
「Link_2」を190の位置に移動するため、servo.moveJoint(0,190)に変更します。
テーブルBのセンサーで検出したコンポーネントを、ワークBとして定義するため、workB=signal2.Valueと記述します。
ワークBのビヘイビアを参照するため、cont3=workB.findBehaviourと記述します。
参照するビヘイビアの名前は、ComponentContainerです。
ワークBのコンテナにワークAを格納するため、cont2.grab(workA)を、cont3.grab(workA)に変更します。
コンパイルをクリックします。
シミュレーションを実行します。
[接続]グループの[シグナル]をクリックし、プッシャーを選択することで、シグナルエディタを表示します。
Downをクリックしてオンにします。
プッシャーが-Z軸方向に動作します。
PositionBをクリックしてオンにします。
プッシャーがワークAをワークBの位置まで押し出したことがわかります。
PositionBをクリックしてオフにします。
PositionAをクリックしてオンにします。
シミュレーション中に、ワーク同士を結合することで、ワークAとワークBを一緒に操作することができます。
[接続]グループの[シグナル]をクリックし、シグナルエディタを非表示にします。
ワークBをダブルクリックして、コンポーネントを選択します。
[コンポーネントプロパティ]ウィンドウの[表示]から、チェックを外します。
[表示]のチェックを外したワークBだけでなく、ワークAも一緒に非表示になったことがわかります。
プッシャーでワーク同士を結合する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

プロセスモデリング用コンベアを作ってみよう

オリジナルのプロセスモデリング用コンベアを作る方法
https://youtu.be/svx78DnYAXo
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_006.zip

プロセスモデリング用のインラインプロセスコンポーネントを作成する方法を説明します。
[モデリング]タブに移動し、新しいコンポーネントを作成しましょう。
[インポート]グループの[ジオメトリ]をクリックすることで、3DCADモデルをインポートすることができます。
パスを作成するため、コンポーネントにフレームを追加します。
フレームが表示されない場合、[フレームタイプ]をクリックし、表示するフレームの種類にチェックをつけます。
追加したフレームは4つあり、3つはパスを作成するためですが、4つ目は、リソースの位置を設定するフレームです。
リソースの位置とは、人が作業を開始する位置、または移動ロボットが所定のコンポーネントを持ち上げる位置です。
フレームを移動します。
動作を追加します。
[1対1接続]を2つと、[1対多接続]を1つと、[ワンウェイパス]を2つ追加します。
追加した1対1接続の名前を、InInterfaceとOutInterfaceに変更し、
1対多接続の名前をSensorInterfaceに変更します。
1つ目のパスは、コンテナにコンポーネントを入力し、2つ目のパスは、コンテナからコンポーネントを出力されます。
パスの名前をPathIn__HIDE__と、PathOut__HIDE__に変更します。
動作名の後に__HIDE__と追記することで、動作のプロパティを非表示にすることができます。
ワークをコンテナから別のコンテナへ流すため、インターフェースに新しいフローフィールドを追加します。
OutInterfaceでは、[Container]にPathoutを設定し、
ポートにOutputを設定することで、ワークはパスから搬出することができます。
SensorInterfaceには、プロセッサーフィールドを追加します。
[コンテナ]と、[キャパシティコントローラー]と、[ブール型]のシグナルを2つ追加します。
[統計]も追加しますが、必須ではありません。
ブール型シグナルの名前をPowerOnSignalに変更し、PathInと接続します。
2番目のブール型シグナルの名前をTransitionSignalに変更します。
PathInを選択し、キャパシティコントローラーとTransitionSignalを接続します。
PathInの[パス]で、[Start]フレーム、[Center]フレームの順番に選択することで、インラインプロセスの開始から中央までのフローが含まれます。
PathOutは、[キャパシティブロック]に[キャパシティコントローラー]を設定し、
[パス]で[Center]フレーム、[End]フレームの順番に選択します。
ComponentContainerを選択し、[統計]、[キャパシティプロパティブロック]を設定します。
コンテナの位置を[Center]フレームに設定します。
次に、コンポーネントコンテナの入力、出力ポートの接続を定義します。
PathInから出力したワークを、コンテナに入力し、コンテナから出力したワークをPathOutに出力します。
次に、プロセスモデリングの動作を追加します。
[トランスポートノード]と[プロセスエグゼキューター]を追加します。
[ビジュアルポジションフレーム]と[デフォルト製品ポジションフレーム]に、[Center]フレームを設定し、
[デフォルトリソースポジションフレーム]に[ResourceLocation]フレームを設定します。
プロセスエグゼキューターをトランスポートノードに接続します。
コンポーネントの動作を確認するため、ステートメントを追加します。
[トランスポートイン]、[ディレイ]、[トランスポートアウト]の順番で追加し、フローを作成します。
[ホーム]タブに移動し、eカタログから[Feeder Process]と[Sink Process]を配置します。
次に、フローラインを定義します。
ラベルをクリックし、[プロセスフローエディタ]を更新します。
シミュレーションを実行し、動作を確認します。
フィーダーがワークを生成し、コンポーネントの中央で10秒待機し、再び流れ始めます。
プロセスモデリング用のインラインプロセスコンポーネントを作成する方法についての説明は以上となります。

=================================================================================

プロセスモデリング用のコンポーネントを作ってみよう

オリジナルの装置を作成して、プロセスモデリングで使用可能にする設定方法
https://youtu.be/4-jpL8YhH5w
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_005.zip

プロセスモデリング用のコンポーネントを作成する方法を説明します。
[モデリング]タブの[ジオメトリ]で、マシンボディをインポートします。
[移動]コマンドで、マシンボディを移動し、ジオメトリを分割します。
ドアを選択し、リンクを抽出します。
右側のドアと左側のドアがあります。
リンク1を選択し、[JointType]を変換に設定します。
[軸]に+Xを設定し、ジョイントの名前をDoorに変更します。
新しいサーボコントローラを作成します。
ドアの可動域を設定するため、最小リミットは0、最大リミットは550に設定します。
リンク2を選択し、[JointType]を「変換フォロワー」に、[軸]を「-X」に、[ドライバー]を「Door」に設定します。
[インタラクティブ]コマンドを使用し、可動域と動作を確認します。
[ジオメトリ]グループの[ツール]を展開し、[マテリアル]の中の[割り当て]を使用することで、コンポーネントの色を変更することができます。
マシンボディの一部を、light_orangeに変更します。
ワークを配置する台を選択し、マシンボディ内部の中心まで移動させます。
次に、マシンボディに、フレームを3つ追加します。
プロセスを実行する位置、プロセスを実行する前の位置、リソースが停止する位置です。
[モデリング]タブに移動し、1番目のフレームを作成します。
フレームを、マシンボディの前に配置します。
人、またはAGVなどのリソースが、ワークを投入する位置です。
[名前]を「ResourceLocation」に変更します。
座標をオブジェクト座標に変更し、フレームを回転させ、X軸をマシンボディの方向に向けることで、人、またはAGVがマシンボディの方向を向きます。
2番目のフレームを作成し、[名前]をProcessLocationに変更します。
フレームを、マシン内部のプロセスを実行する位置に移動し、反時計回りに90度回転させます。
3番目のフレームを作成し、ロボットがProcessLocationに接近する位置に移動します。
ロボットは、プロセスを実行する位置にワークを配置する前に、3番目のフレームに移動します。
フレームの[名前]をProcessLocationAproachに変更します。
3つのフレームを追加したので、[ビヘイビア]からワークを格納する[コンテナ]を追加します。
コンテナの名前をCmponentContainer__HIDE__に変更します。
[ビヘイビア]から[統計]を追加することもできます。
必須ではありませんが、統計を追加します。
プロセスモデリングの動作を追加します。
トランスポートノードを追加します。
マシンボディ内の加工する位置を定義するため、[コンポーネントコンテナ]に作成したコンテナを設定し、[ビジュアルポジション]にProcessLocationフレームを設定します。
[デフォルト製品ポジションフレーム]はProcessLocationフレーム、[デフォルトリソースポジションフレーム]はResourceLocationフレームです。
マシンボディの内部に、ノードを配置するため、フレームを設定します。
プロセスエグゼキューターを追加し、トランスポートノードを設定します。
[トランスポートノード]に作成したトランスポートノードを設定することで、ワークをコンポーネントの内部、または外部へ転送することができます。
コンポーネントコンテナに移動し、統計を設定します。
[プロセス]タブに移動し、[エディタ]グループの[プロセス]をクリックすることで、他のコンポーネントに、ラベルがついていることが確認できますが、
マシンボディには、プロセスが含まれていないので、ラベルが表示されません。
マシンボディの青丸をクリックし、プラスボタンをクリックすることで、プロセス1が作成されます。
名前をMyMillingに変更します。
プロセスにステートメントを追加します。
最初に、[統計ステートメント]の中の[状態の設定]を追加することで、マシンボディに設定した統計を、変更することができます。
ワークが到着するまで待機し、ワークをプロセスに搬入するので、[トランスポートイン]を追加します。
[トランスポート待機]を追加し、1秒遅延させます。
ドアを閉めるため、[ジョイントを移動]を追加します。
選択したジョイントを移動させることができるので、[ステートメントプロパティ]で、サーボコントローラとDoorジョイントを選択し、[ターゲット値]を550、[モーション時間]を1に設定することで、ドアを1秒で550mm移動させることができます。
[状態の設定]を追加します。
[ディレイ]を追加し、プロセスの実行を遅延させます。
[モデリング]タブで、[分散]を作成し、[名前]を「ProcessTime」に変更し、[量]を「Time」、[マグニチュード]を「s」、[値]を5秒に設定します。
[プロセス]タブに戻り、ディレイを選択します。
[時間ソース]を数式に変更し、[数式]に作成した分布を設定します。
プロセスの実行時間を設定することもできます。
ドアを開くため、[ジョイントを移動]を追加し、[ステートメントプロパティ]で、サーボコントローラとジョイントを選択します。
[ターゲット値]を0、[モーション時間]を1に設定します。
[状態の設定]を追加します。
リソースが到着し、ワークを持ち上げるまで待機するので、[State]をBlockedに設定します。
プロセスからワークを搬出するため、[トランスポートアウト]を追加します。
マシンボディを、ロボットの横まで移動します。
ロボットが動作することができるスペースを確保し、コンポーネントを配置します。
ワークが最初のマシンから、今回カスタマイズしたマシンに移動し、コンベアに搬送するフローに変更します。
[エディタ]グループの[フロー]をクリックします。
フローグループ番号1のToConveyorを削除し、3Dワールドで、最初のマシンとコンベアをつなぐ矢印を削除します。
最初のマシン、カスタマイズしたマシン、コンベアの順番にラベルを選択し、ロボットコントローラーと矢印上にあるアイコンをクリックします。
右クリックから[トランスポートコントローラを変更]を選択し、ロボットで搬送する設定をします。
シミュレーションを実行し、動作を確認します。
一方のコンベアでは立方体が流れ、もう一方では箱が作成されました。
ロボットが、立方体を2つのマシンに搬送し、箱に立方体を投入しました。
プロセスモデリング用のコンポーネントを作成する方法についての説明は以上となります。

=================================================================================

プロパティに入力規則を設定しよう

パイソンスクリプト（Python）を使用して、値の範囲などの制約付きのプロパティを作成する方法
https://youtu.be/5Cx6DyYGBiU

プロパティに入力規則を設定する方法を説明します。
実数のプロパティを作成し、指定した範囲内の値を表示します。
[モデリング]タブを開きます。
[コンポーネント]-[新規]を選択し、コンポーネントを作成します。
[ジオメトリ]-[フィーチャ]-[ブロック]を選択し、ブロックを作成します。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
パイソンスクリプトダイアログが開くため、デフォルトで記述されているソースコードを1行目以外削除します。
comp = getComponent()と記述し、Pythonスクリプトを設定しているコンポーネントを取得します。
prop = comp.getProperty()と記述し、コンポーネント内に指定したプロパティが存在するか確認します。
"Test_Real"というプロパティ名を探します。
if not prop: prop = comp.createProperty()と記述し、プロパティが存在しない場合、プロパティを作成します。
実数を格納できるプロパティを作成するため、VC_REALと記述します。
プロパティに表示する文字は"Test_Real"とします。
プロパティ作成時に、使用できる制約が3種類あります。
VC_PROPERTY_DEFAULTと記述すると、制約はなしになります。
VC_PROPERTY_LIMITと記述すると、プロパティに最小値や最大値を定義できます。
VC_PROPERTY_LIMITは、実数もしくは整数のプロパティを作成する際に使用できます。
VC_PROPERTY_STEPと記述すると、ステップと呼ばれる値を定義できます。
ステップ値をドロップダウンメニューの選択肢で表示し、その中から値を選択できるようになります。
VC_PROPERTY_STEPは、実数、整数、もしくは文字列のプロパティを作成する際に使用できます。
今回は、VC_PROPERTY_DEFAULTと記述し、制約をなしにします。
VC_PROPERTY_LIMITと記述し、最小値と最大値を定義します。
prop.MinValue = 10.5と記述し、最小値を10.5にします。
prop.MaxValue = 200.33と記述し、最大値を200.33にします。
prop.Value =50.5と記述し、最小値と最大値の範囲内である、50.5を割り当てます。
コンパイルボタンをクリックします。
[コンポーネントグラフ]ウィンドウのプロパティの表示がオンになっていることを確認します。
プロパティを展開すると、Test_Realが追加されていることがわかります。
Test_Realには、50.5の値が割り当てられています。
Test_Realを選択し、[プロパティ]ウィンドウの[制約]を確認すると、10.5～200.33の制約が反映されていることがわかります。
文字列プロパティを作成し、VC_PROPERTY_STEPの制約を使用します。
"Test_String"と記述し、Test_Stringというプロパティを探します。
Test_Stringのプロパティが存在しない場合、プロパティを作成します。
文字列を格納できるプロパティを作成するため、VC_STRINGと記述します。
プロパティに表示する文字は"Test_String"とします。
VC_PROPERTY_STEPと記述し、ステップの値を定義します。
最小値や最大値を割り当てる必要はないため、prop.MinValueからprop.valueまでの記述を削除します。
プロパティにステップの値を定義する必要があるため、prop.StepValuesと記述します。
選択肢を、red、green、blueの3つ定義します。
prop.Value =と記述し、選択肢の何番目を選択するか、割り当てます。
prop.StepValuesと記述し、使用したい選択肢のインデックスの位置を値で指定します。
redが0、greenが1、blueが2となるため、1と記述し、greenを割り当てます。
コンパイルボタンをクリックします。
[コンポーネントグラフ]ウィンドウを確認すると、Test_Stringが追加されていることがわかります。
Test_Stringには、greenが割り当てられています。
コンポーネントを使用してプロパティを作成しましたが、オブジェクトにプロパティを作成することもできます。
ブロックの[フィーチャプロパティ]ウィンドウに、新しいプロパティを作成します。
prop = Comp.getProperty以下の記述をコメントアウトし、コードを無効化します。
コメントアウトするには、アポストロフィーをコメントアウトしたいソースコードの最初と最後に3つずつ付けます。
block = comp.getFeatureと記述し、ノード内のフィーチャを取得します。
今回は、ブロックのルートノードを取得します。
prop =block.getProperty()と記述し、ブロック内に指定したプロパティが存在するか確認します。
"Test_Integer"というプロパティ名を探します。
if not prop: prop = block.createProperty()と記述し、ブロック内にプロパティが存在しない場合、プロパティを作成します。
整数を格納できるプロパティを作成するため、VC_INTEGERと記述します。
プロパティに表示する文字は"Test_Integer"とします。
prop.Value = 400というように数値を割り当てることもできますが、0x0000FFと記述し、16進数の値を割り当てることもできます。
pythonでは、0xが16進数を意味します。
16進数の0000FFは、10進数では255となります。
コンパイルボタンをクリックします。
ブロックを選択します。
[フィーチャプロパティ]ウィンドウを確認すると、Test_Integerが追加されていることがわかります。
Test_Integerには、255が割り当てられています。
今回使用したPython APIは、ヘルプから確認することができます。
[ヘルプ]タブをクリックします。
[パイソンAPI]をクリックすると、ヘルプダイアログが表示されます。
[目次]-[Japanese]-[vcComponent]を開きます。
[メソッド]をクリックすると、createPropertyがあります。
createPropertyは、プロパティを作成します。
getPopertyは、プロパティを取得します。
createPropertyの定数は、property Constantsのリンクをクリックすると、確認できます。
定数(Constraints)で、制約の種類を確認できます。
タイプのプロパティで作成するプロパティの種類を確認できます。
すべての種類のプロパティが、LIMITとSTEPの2つの制御をサポートしているわけではありませんので、ご注意ください。
[vcFeature]を開きます。
[メソッド]をクリックすると、createPropertyやgetPropertyなど、vcComponentと同じメソッドがあります。
プロパティに入力規則を設定する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

プロパティの数量と単位を定義しよう

パイソンスクリプト（Python）を使用して、数量と単位を指定できるプロパティを作成する方法
https://youtu.be/Ee4T6jqQ5AU
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_099.zip

プロパティの数量と単位を定義する方法を説明します。
Python APIを使用して、プロパティを作成し、数量と単位を定義します。
[モデリング]タブを開きます。
[コンポーネント]-[新規]を選択し、コンポーネントを作成します。
[ジオメトリ]-[フィーチャ]-[ブロック]を選択し、ブロックを作成します。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
パイソンスクリプトダイアログが開くため、デフォルトで記述されているソースコードを1行目以外削除します。
温度を示すプロパティを作成します。
comp = getComponent()と記述し、Pythonスクリプトを設定しているコンポーネントを取得します。
prop = comp.getProperty()と記述し、コンポーネント内に指定したプロパティが存在するか確認します。
Test_Temperatureというプロパティ名を探します。
if not prop: prop = comp.createProperty()と記述し、プロパティが存在しない場合、プロパティを作成します。
実数を格納できるプロパティを作成するため、VC_REALと記述します。
プロパティの名前は"Test_Temperature"とします。
prop.Value = 38.0と記述します。
コンパイルボタンをクリックします。
[コンポーネントグラフ]ウィンドウのプロパティの表示がオンになっていることを確認します。
プロパティを展開すると、Test_Temperatureが追加されていることがわかります。
Test_Temperatureには、38の値が割り当てられています。
Test_Temperatureを選択し、[プロパティ]ウィンドウの[値]を確認すると、38が反映されています。
[単位]を確認すると、[量]や[マグニチュード]が選択されておらず、割り当てられていないことがわかります。
温度の単位を追加します。
app = getApplication()と記述し、アプリケーション情報を取得します。
quant = app.findQuantity()と記述し、指定した数量が存在するか確認します。
温度の数量を取得するため、Temperatureを探します。
if not prop: quant = app.createQuantity()と記述し、数量が存在しない場合、数量を作成します。
数量の名前は"Temperature"とします。
数量のタイプはスカラーまたはベクトルを指定できます。
ベクトルで数量を表すには、方向または力が必要です。
例えば、時間と質量はスカラー、加速と重みはベクトルになります。
温度には方向がないため、VC_QUANTITY_SCALARと記述します。
prop.Quantity = quantと記述します。
コンパイルボタンをクリックします。
[コンポーネントグラフ]ウィンドウのTest_Temperatureを確認すると、-235.15℃と表示されます。
温度は摂氏、華氏、ケルビンで表すことができます。
国際単位系（SI）は、ケルビンを採用しているため、Geminiのプロパティでは摂氏がケルビンに変換された値が割り当てられます。
ケルビンの0Kは、摂氏の-273.15℃にあたるため、-273.15+38に変換され、-235.15が表示されています。
華氏に変更する場合は、[ファイル]タブの[オプション]-[一般]-[パーソナライズ]-[単位]で変更することができます。
今回は、摂氏を使用するため、パイソンスクリプトで値を変換します。
unit = quant.getEffectiveUnit()と記述し、指定した数量の情報を取得します。
今回は、38.0℃の情報を取得するため、38.0と記述します。
print unit.Name, unit.Factor, unit.Offsetと記述し、[出力]ウィンドウに単位の名前、係数、0を基準とした場合の数量の差を表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウに名前は摂氏、係数は1.0、ケルビンとの差は273.15が表示されます。
print関数に#を付けてコメントアウトします。
print 38.0 - unit.offsetと記述し、[出力]ウィンドウに38.0-273.15の結果を表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウに38.0-273.15の結果、つまり、-235.15が表示されます。
[コンポーネントグラフ]ウィンドウに表示されている温度は-235.15℃のため、Geminiのプロパティはケルビン+38.0の値を表示していることがわかります。
ケルビンを摂氏に変換し、Geminiのプロパティに38.0℃と表示します。
print関数に#を付けてコメントアウトします。
prop.Valueの38.0を削除し、unit.convertToCanonical()と記述し、指定した値の単位を変換します。
今回は、38.0の値をケルビンから摂氏の温度の表記に変換するため、38.0と記述します。
コンパイルボタンをクリックします。
[コンポーネントグラフ]ウィンドウのTest_Temperatureを確認すると、38℃と表示され、摂氏に変換されたことがわかります。
Test_Temperatureを選択し、[プロパティ]ウィンドウの[値]を確認すると、38が反映されています。
[単位]を確認すると、[量]にTemperature、[マグニチュード]に℃が割り当てられています。
なお、プロパティの見た目上は摂氏に変換されましたが、内部的にはケルビンの値が割り当てられている状態です。
print unit.convertToCanonical(38.0)と記述し、[出力]ウィンドウに38.0の単位を変換した値を出力します。
コンパイルボタンをクリックします。
[出力]ウィンドウに311.15と表示されます。
摂氏38.0℃はケルビン311.15Kのため、ケルビンの値が実際には使用されていることがわかります。
print関数に#を付けてコメントアウトします。
print prop.Valueと記述し、[出力]ウィンドウにプロパティの値を表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウに311.15と表示され、ケルビンの値が使用されていることがわかります。
今回使用したPython APIは、ヘルプから確認することができます。
[ヘルプ]タブをクリックします。
[ヘルプ]をクリックすると、ヘルプダイアログが表示されます。
[目次]-[数式]を開きます。
[単位指定]をクリックし、[組み込み単位]をスクロールすると、摂氏温度と華氏温度の項目があります。
[備考]は[なし]になっているため、標準の単位として使用されていないことがわかります。
再度スクロールすると、[ケルビン]の項目があります。
[備考]は[標準]になっているため、標準単位として内部処理で使用されていることがわかります。
ヘルプダイアログを閉じます。
[パイソンAPI]をクリックすると、パイソンAPIに関するヘルプダイアログが表示されます。
[目次]-[Japanese]-[vcApplication]を開きます。
[メソッド]をクリックし、[単位]の項目までスクロールすると、findQuantityがあります。
findQuantityは、Geminiに登録されている数量を名前で検索します。
[Return Type]のvcScalarQuantityをクリックすると、数量の説明が表示されます。
[メソッド]をクリックすると、getEffectiveUnitがあります。
getEffectiveUnitは、大きさや量の測定に最適な単位を取得します。
[Return Type]のvcUnitをクリックすると、単位の説明が表示されます。
[メソッド]をクリックすると、convertToCanonicalがあります。
convertToCanonicalは、指定した値の単位を変換します。
プロパティの数量と単位を定義する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

プロパティのボタンをクリックした時の動作を設定しよう

コンポーネントプロパティのボタンをパイソンスクリプト（Python）で動的に作成する方法、そのボタンをクリックした時の動作をパイソンスクリプトで設定する方法
https://youtu.be/xXsFL9I3Yms

Python APIを使用して、ボタンの作成や実行をする方法を説明します。
Geminiのアプリケーション内にボタンを作成し、実行することで、メッセージを表示できるようにします。
[モデリング]タブを開きます。
[コンポーネント]-[新規]を選択し、コンポーネントを作成します。
[ジオメトリ]-[フィーチャ]-[ブロック]を選択し、ブロックを作成します。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
パイソンスクリプトダイアログが開くため、デフォルトで記述されているソースコードを1行目以外削除します。
comp = getComponent()と記述し、Pythonスクリプトを設定しているコンポーネントを取得します。
prop = comp.getProperty()と記述し、コンポーネント内に指定したプロパティが存在するか確認します。
Test_Buttonというプロパティ名を探します。
if not prop: prop = comp.createProperty()と記述し、プロパティが存在しない場合、プロパティを作成します。
ボタンタイプのプロパティを作成するので、VC_BUTTONと記述します。
ボタンに表示する文字は"Test_Button"とします。
prop.OnChanged=testと記述し、ボタンを押した時、testという関数を呼び出します。
app = getApplication()と記述し、アプリケーション情報を取得します。
def testと記述し、testの関数を作成します。
引数はpropとします。
app.messageBox("Hello World")と記述し、メッセージボックスにHello Worldと表示します。
コンパイルボタンをクリックします。
[コンポーネントグラフ]ウィンドウのプロパティの表示がオンになっていることを確認します。
プロパティを展開すると、Test_Buttonが追加されていることがわかります。
値は何も入っていないため、nullまたはNoneが表示されます。
Test_buttonをクリックします。
[プロパティ]ウィンドウの値にTest_Buttonが追加されていることがわかります。
Test_Buttonをクリックすると、メッセージボックスが表示されます。
メッセージには、Hello Worldと表示されています。
中止ボタンをクリックし、メッセージボックスを閉じます。
作成したボタンをコメントアウトし、新しいボタンを作成します。
prop = comp.getProperty()以下をコメントアウトし、コードを無効化します。
コメントアウトするには、アポストロフィーをコメントアウトしたいソースコードの最初と最後に3つずつ付けます。
ブロックの[フィーチャプロパティ]ウィンドウに、ブロックを拡大表示するボタンを作成します。
block = comp.getFeatureと記述し、ノード内のフィーチャを取得します。
今回は、ブロックのルートノードを取得します。
prop =block.getProperty()と記述し、ブロック内に指定したプロパティが存在するか確認します。
Test_Buttonというプロパティ名を探します。
if not prop: prop = block.createProperty()と記述し、ブロック内にプロパティが存在しない場合、プロパティを作成します。
ボタンタイプのプロパティを作成するので、VC_BUTTONと記述します。
ボタンに表示する文字は"Test_Button"とします。
prop.OnChanged=showMeと記述し、ボタンを押した時、showMeという関数を呼び出します。
def showMeと記述し、showMeの関数を作成します。
引数はpropとします。
app = getApplication()と記述し、アプリケーションのオブジェクト情報を取得します。
sm = app.SelectionManagerと記述し、3Dワールド内のオブジェクトを選択します。
sm.setSelection(block)と記述し、ブロックのフィーチャを選択します。
選択したフィーチャを3Dワールド全体に拡大するコマンドを使用します。
cmd = app.findCommand("netCommand")と記述し、.NETコマンドと言うPythonAPIのコマンドを呼び出します。
.NETコマンドは、.NET APIで定義された、Geminiに登録されているコマンドです。
.NETは、マイクロソフト社によって作成されたWindows上の開発環境のことです。
cmd.execute()と記述し、コマンドを実行します。
3Dワールドいっぱいに拡大するので、FillSelectedのコマンドを指定します。
FillSelectedコマンドは、3Dワールドツールバーの[選択と拡大]をクリックしたときに実行されるコマンドと同じです。
コンパイルボタンをクリックします。
PythonScriptのウィンドウを最小化します。
ブロックを選択し、[フィーチャプロパティ]ウィンドウを確認すると、Test_Buttonが追加されていることがわかります。
ブロックの表示位置が3Dワールド画面外になるように、視点を変更します。
Test_Buttonをクリックすると、視点が変更し、3Dワールド全体に拡大されます。
ブロックの長さと高さを大きくし、ブロック全体が画面から見切れるようにします。
[フィーチャプロパティ]の[長さ]を5000、[高さ]を6000に変更します。
Test_Buttonをクリックすると、視点が変更し、3Dワールド全体に拡大されます。
今回使用したPython APIは、ヘルプから確認することができます。
[ヘルプ]タブをクリックします。
[パイソンAPI]をクリックすると、ヘルプダイアログが表示されます。
[目次]-[Japanese]-[vcProperty]を開きます。
[イベント]をクリックすると、OnChangedがあります。
プロパティの値が変更されると、トリガーされます。
[vcApplication]を開きます。
[メソッド]をクリックし、[雑則]の項目までスクロールすると、messageBoxがあります。
messageBoxは、メッセージボックスを表示します。
[コマンド]の項目までスクロールすると、findCommandがあります。
findCommandは、Geminiに登録されているコマンドを名前で検索します。
getCommandsは、コマンドのリストを返しますが、不要なコマンドを見つけないようにするため、今回はfindCommandを使用し、コマンドを指定しました。
[Return Type]のvcCommandをクリックすると、コマンドのリストが表示されます。
[使用可能な標準コマンド]の項目までスクロールすると、netCommandがあります。
netCommandを使用すると、.NETコマンドを実行できます。
Python APIを使用して、ボタンの作成や実行をする方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

プロパティやシグナルの変化時にPythonを実行しよう

プロパティやシグナルの値の変化などのイベントが発生した時に、パイソンスクリプト（Python）を実行する方法
https://youtu.be/XXYHHEmZuyQ
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_072.zip

イベントを使用して処理を実行する方法を説明します。
プロパティの値の変化など、イベントが発生したときにPythonScriptの処理を呼び出します。
動画内で使用するGeminiのファイルをダウンロードします。
ファイル名は、[EventHandlersStart.vcmx]です。
ファイルを開くと、Geminiにコンポーネントが表示されます。
[モデリング]タブを開きます。
3Dワールドのコンポーネントを選択します。
[コンポーネントグラフ]ウィンドウのノードツリーをすべて展開するため、「＋」を選択します。
プロパティの[PlatformLength]は、台座の長さを表示しています。
値は700です。
ビヘイビアの[Servo]は、コンポーネントを駆動させるためのサーボコントローラです。
[プロパティ]ウィンドウの[ジョイント]にJoint_XとJoint_Yが設定されています。
[Link_1]の[リンクプロパティ]ウィンドウの[Name]は、[Joint_X]です。
[Link_2]の[リンクプロパティ]ウィンドウの[Name]は、[Joint_Y]です。
つまり、Servoで「Link_1」と「Link_2」のコンポーネントを駆動できます。
[コンポーネントグラフ]ウィンドウのルートノードを選択します。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
OnChangedイベントを使用して、プロパティの値が変更されると、[出力]ウィンドウにメッセージを表示するように記述します。
def OnSignalを削除します。
comp = getComponent()と記述し、Pythonスクリプトを設定しているコンポーネントを取得します。
platform_length = comp.getProperty("PlatformLength")と記述し、プロパティのPlatformLengthを取得します。
platform_length.OnChanged = LengthChangeと記述し、platform_lengthの値が変わるとLengthChangeという関数を呼び出します。
def LengthChangeと記述し、LengthChangeの関数を作成します。
引数はpropertyとします。
print "Platform length changed to %.2f"と記述し、[出力]ウィンドウにplatform lengthの変更後の値を表示します。
%.2fで、小数点第二位までの値を表示できます。
プロパティの値を表示するため、%property.Valueと記述します。
コンパイルボタンをクリックします。
[コンポーネントグラフ]ウィンドウのルートノードを選択します。
[コンポーネントプロパティ]ウィンドウの[PlatformLength]の値を1000に変更します。
[出力]ウィンドウを確認すると、値が1000に変更されたという内容のメッセージが表示されます。
OnValueChangeイベントを使用して、シグナルの値が変更されると、[出力]ウィンドウにメッセージを表示するように設定します。
[動作設定]-[ビヘイビア]-[シグナル]-[ブール型]を選択し、[BooleanSignal]を追加します。
[プロパティ]ウィンドウの[接続]をクリックします。
プラスボタンが表示されるため、クリックすると、[Add 'Connections' items]ダイアログが表示されます。
[Python Script]を選択すると、[接続]に追加されたことがわかります。
シグナルを条件にスクリプトを処理したい場合は、Python Scriptと接続した信号を使用することができます。
[Add 'Connections' items]ダイアログを閉じます。
[ジオメトリ]-[フィーチャ]-[その他]-[フレーム]を選択し、フレームを追加します。
[ツール]-[スナップ]を選択し、フレームを台座の上面中央に合わせます。
[動作設定]-[ビヘイビア]-[センサー]-[レイキャスト]を選択し、[RaycastSensor]を追加します。
レイキャストセンサーの検知状態を出力するため、ブール型のシグナルを追加します。
[プロパティ]ウィンドウの[ブールシグナル]で、[BooleanSignal]を選択します。
[フレーム]で、[フレーム]を選択します。
シグナルの値は、シミュレーション実行中にセンサーがトリガーされる度に変更されます。
[コンポーネントグラフ]ウィンドウの[PythonScript]を開きます。
OnRun内のpassを削除します。
servo = comp.findBehaviour("Servo")と記述し、ビヘイビアのServoを取得します。
while True:と記述し、ループ処理します。
servo.moveJointと記述し、コンポーネントの動作範囲を設定します。
サーボコントローラを割り当てたLinkの番号を指定します。
Link1を動かすため、0番目にします。
Link1のコンポーネントは800mm動かすため、800.0と記述します。
delay(5)と記述し、Link1のコンポーネントの移動後、5秒待機します。
servo.moveJoint(0,0.0)と記述し、0mmに戻します。
signal = comp.findBehaviour("BooleanSignal")と記述し、ビヘイビアのBooleanSignalを取得します。
signal.OnValueChange = JointValuesと記述し、signalの値が変わるとJointValuesという関数を呼び出します。
def JointValuesと記述し、JointValuesの関数を作成します。
引数はsignalとします。
jointX = comp.Joint_Xと記述し、センサーが検知した時のLink1の値をJointXに格納します。
jointY = comp.Joint_Yと記述し、センサーが検知した時のLink2の値をJointYに格納します。
print "Joint X is %s and Joint Y is %s"と記述し、[出力]ウィンドウにセンサーが検知した時のJointXとJointYの値を表示します。
%sで、文字列を表示できます。
JointXとJointYの値を表示するため、%(jointX,jointY)と記述します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
Link1のコンポーネントはX軸方向に動作しますが、センサーを通っても[出力]ウィンドウに検知した時の位置が表示されません。
シミュレーションをリセットします。
センサーがコンポーネントを検知するように設定します。
[コンポーネントグラフ]ウィンドウの[RaycastSensor]を選択します。
[プロパティ]ウィンドウの[親テスト]を確認すると、チェックが入っていません。
センサーは自分自身のコンポーネントを検知することができません。
[親テスト]にチェックを入れることで、自分自身のコンポーネントを検知することができます。
今回、台座とLink1、2のコンポーネントは1つの同じコンポーネント内にあるため、[親テスト]にチェックを入れる必要があります。
[プロパティ]ウィンドウの[親テスト]にチェックを入れます。
[コンポーネントグラフ]ウィンドウの[フレーム]を選択します。
[フィーチャプロパティ]ウィンドウの[座標]で[親]を選択します。
座標を親とすることで、装置をフレームの座標の基準にできます。
センサーが台座に触れている場合、センサーが常に台座を検知してしまうため、Z軸座標に1を追加し、上にセンサーを移動させます。
シミュレーションを実行します。
[出力]ウィンドウに、センサーが検知した時のJointXとJointYの値が表示されます。
Link1、2のコンポーネントがセンサーに触れたときと、触れなくなったときに検知した値が表示されていることがわかります。
シミュレーションをリセットします。
OnHeartbeatイベントを使用して、サーボコントローラのパルスを使用し、[出力]ウィンドウにメッセージを表示するように設定します。
[コンポーネントグラフ]ウィンドウの[Servo]を選択します。
[プロパティ]ウィンドウの[パルスを使用]にチェックを入れます。
パルスは、物体の計測や検知ができる、ONOFF信号です。
パルスを使用することで、移動中・停止中などのコンポーネントの動作ステータスを取得できます。
[パルス時間]は0.01にします。
[コンポーネントグラフ]ウィンドウの[PythonScript]を開きます。
サーボコントローラのステータスと表示したい文字列を記述します。
typemapを使用し、ステータスと文字列の対応表を作成します。
VC_CONTROLLER_START:"Start"と記述し、検知したいコンポーネントがスタートの位置にいる状態をStartの文字列とします。
VC_CONTROLLER_RUNNING:"Running"と記述し、検知したいコンポーネントが移動中の状態をRunningの文字列とします。
C_CONTROLLER_END:"End"と記述し、検知したいコンポーネントがゴールの位置にいる状態をEndの文字列とします。
VC_CONTROLLER_STOP:"Stop"と記述し、検知したいコンポーネントが停止中の状態をStopの文字列とします。
OnRun内にservo.OnHeartbeat = HeartbeatStateと記述し、ステータスが変わるとHeartbeatStateという関数を呼び出します。
def HeartbeatStateと記述し、HeartbeatStateの関数を作成します。
引数は、servo,typeとします。
print"Servo heartbeat type %s"と記述し、[出力]ウィンドウにステータスを表示します。
typemapの文字列を表示するため、%typemap[type]と記述します。
Link1と2のコンポーネントを両方動かすため、OnRun内のservo.moveJointを削除します。
moveJointは指定した1つのジョイントのみを動かします。
今回はLink1と2の両方、つまり全てのジョイントを同時に動かしたいため、すべてのジョイントを同時に動かすことができるmoveを使用します。
servo.move(800.0,800.0)と記述し、Link1と2のコンポーネントを800mm動かします。
servo.move(0,0.0)と記述し、Link1と2のコンポーネントを0mmに戻します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
Link1と2のコンポーネントが800mm移動します。
[出力]ウィンドウに、Start、Runningなどのステータスが表示されます。
イベントを使用して処理を実行する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ボリュームセンサを使ってみよう

人感センサー等を表現（空間中の部品を検出する面を設定）する方法
https://youtu.be/bmy0A2VckXw
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_012.zip

ボリュームセンサーの説明をします。
eカタログの[タイプ別モデル]をクリックします。
[Component Templates]をクリックし3Dワールドに「Feeder Template」と「Conveyor Template」をダブルクリックで追加します。
コンベアとフィーダーをPnP接続します。
シミュレーションを再生します。
フィーダーからワークが生成されワークはコンベアのパスに沿い移動します。
このコンベアにボリュームセンサーを追加してワークが特定の範囲に差し掛かると検知できるようにします。
シミュレーションをリセットします。
コンベアを選択した状態で[モデリング]タブに移動します。
[動作設定]グループの[ビヘイビア]をクリックし[センサー]の中から[ボリューム]を選択することでボリュームセンサーを追加することができます。
ボリュームセンサーがワークを検出する位置を設定します。
フレームを設定します。
3Dワールドでフレームを表示していない場合3Dワールドツールバーのフレームタイプをクリックしフレームにチェックをつけます。
コンベアのパスフレームが表示されます。
ボリュームセンサの検出範囲を設定するため検出したい範囲の左下と右上にフレームを設定します。
[ジオメトリ]グループの[フィーチャ]をクリックし[フレーム]を選択することで新しいフレームを追加します。
[マニピュレーション]グループの[移動]でフレームを「MidFrame」と同じ位置に移動します。
フィーチャプロパティに移動しオブジェクト座標に変更します。
フレームをX軸方向に100、Y軸方向に-100移動します。
検出範囲の左下に設定するためフレームの名前を「LowerFrame」に変更します。
先ほどと同じ手順で別のフレームを追加します。
フレームを「MidFrame」と同じ位置に移動します。
フィーチャプロパティに移動しオブジェクト座標をクリックします。
フレームをX軸方向に100、Y軸方向に100、Z軸方向に200移動します。
検出範囲の右上に設定するためフレームの名前を「UppderFrame」に変更します。
2つのフレームを使用してセンサの検出範囲を定義します。
コンポーネントグラフに移動し「VolumeSensor」を選択します。
プロパティの[ロウアーフレーム]に「LowerFrame」、[アッパーフレーム]に「UppderFrame」を設定します。
オレンジ色の面がワークを検出する範囲です。
3Dワールドにセンサーの検出範囲を表示しない場合プロパティにある[ボリューム表示]のチェックを外します。
検出範囲を非表示にした場合はフレームで検出範囲を確認します。
センサーがワークを検知したことを通知するためのシグナルを作成します。
ビヘイビアをクリックします。
シグナルからブール型を選択しブールシグナルを追加します。
コンポーネントを選択しコンポーネントシグナルを追加します。
次に2つのシグナルをセンサーに設定します。
VolumeSensorを選択しプロパティでコンポーネントシグナルにComponentSignalを設定します。
ブールシグナルにBooleanSignalを設定します。
Pythonスクリプトを追加しシミュレーション中にセンサがワークを検知し動作するように設定します。
ビヘイビアをクリックしPythonスクリプトを追加します。
2つの変数を作成します。
comp=getComponent()と記述します。
getComponentはVC ScriptからインポートされPythonスクリプトを含むコンポーネントの情報を取得します。
センサーの変数を定義します。
sensor=comp.findBehaviour()と記述することでコンポーネントのビヘイビアからカッコ内で定義するものの情報を変数へ代入します。
センサの情報を取得するためカッコ内にVolumeSensorと記述します。
OnSignalまたはOnRunにプログラムを記述します。
OnSignalにPythonスクリプトと接続しているシグナルの値を変更する記述をします。
センサーには2つのシグナルがあるためPythonスクリプトに接続することでスクリプト内で使用することができます。
BooleanSignalを選択します。
[プロパティ]に移動し[接続]を展開します。
+ボタンをクリックしPythonスクリプトを選択します。
[接続]に追加したためシグナルの値に変化があるとPythonスクリプトに通知します。
ComponentSignalを選択し[接続]にPythonスクリプトを追加します。
エディタに戻りOnSignalに記述します。
シグナルがオンになるとシグナルの値を[出力]ウィンドウに表示したいため「print signal.Value」と記述します。
Pythonスクリプトのウィンドウの左上のアイコンをクリックしPythonスクリプトをコンパイルします。
VolumeSensorを選択します。
コンベアのパスを流れるワークを検出させるためプロパティの検出コンテナにメインパスを設定します。
シミュレーションを再生します。
PythonスクリプトでOnSignalを取得していません。
シミュレーションをリセットします。
センサーがワークを検出したため[出力]ウィンドウにコンポーネントシグナルとブールシグナルの値を表示します。
ワークがセンサーを通過しリセットされるためコンポーネントシグナルの値はNone、ブールシグナルの値はFalseになります。
[出力]ウィンドウに表示している記述を右クリックでクリアを選択して削除します。
Pythonスクリプトのエディタに戻りシグナルの値を出力する記述を削除し「if signal.Value == True:」と記述します。
センサーがワークを検出したときコンベアを停止します。
「sensor.DetectionContainer」と記述することでセンサーの検出コンテナを参照することができます。
ビヘイビアは[Enabled]プロパティによって有効無効の設定をすることができます。
値をFalseにしパスを停止させます。
Pythonスクリプトをコンパイルしシミュレーションを再生します。
ワークがコンベアの中央で停止し次のワークはコンベアを流れません。
ワークはセンサーの検出範囲に到達することで停止し次のワークはパスが無効であるためコンベアを移動できません。
Pythonスクリプトを変更しパスではなくワークを停止する記述に変更します。
シミュレーションをリセットします。
Pythonスクリプトのエディタに戻りパスを無効にする記述をコメントアウトします。
「sensor.ComponentSignal」と記述することでセンサーのコンポーネントシグナルを参照します。
コンポーネントシグナルの値はコンポーネントオブジェクトであるため「stopMovement()」と記述しコンポーネントの動作を停止します。
シグナルの値がTrueの場合ワークを検知します。
センサのコンポーネントシグナルの値は検出したワークであるためワークを停止させることができます。
Pythonスクリプトをコンパイルしシミュレーションを再生します。
ワークが停止しました。
パスは無効になっていないため次のワークはコンベア上を移動します。
シミュレーションをリセットします。
ボリュームセンサーのテスト方法を変更します。
「VolumeSensor」に戻り[テスト方法]を「BBoxバウンディングボックス」に設定することでコンポーネントがセンサーの検出範囲と交差するタイミングを変更することができます。
コンポーネント内のジオメトリを検知します。
「BBoxインターセクト」はコンポーネントの中心が検出範囲の内側にある場合検知します。
「BBOXセンターインサイド」はコンポーネント全体が検出範囲の内側にある場合検知します。
検出範囲を平面から空間に変更するため検出範囲の左下を示す「LowerFrame」の位置を変更します。
[マニピュレーション]グループの[移動]を使用しX軸方向に約-200mm移動します。
2つのフレームの間がセンサーの検出範囲です。
ボリュームセンサーに戻り設定を確認します。
シミュレーションを再生します。
シミュレーションを一時停止します。
ボリュームセンサーはコンベアコンポーネントのルートノードにありワークは3Dワールドに接続されたルートノードでもあります。
センサーとワークは同じノード階層にあります。
センサーの設定を変更します。
[兄弟テスト]にチェックをつけます。
センサーと同じ階層にあるノードのジオメトリをセンサーが検出するようになります。
シミュレーションを再生します。
ワークが流れ停止しました。
センサーは3Dワールドの同じノード階層でパス内のワークを検知する指示が出されているためワークを検知し停止しました。
シミュレーションを一時停止します。
ワークを確認するため[ツール]グループの[測定]をクリックし[スナップタイプ]を「境界」に設定します。
ワークにカーソルを合わせることでワーク全体を囲む最小のボックスが表示されます。
最初のエッジがセンサーの検出範囲と交差することでワークを検出しました。
シミュレーションをリセットしエスケープキーを押し測定モードを解除します。
[テスト方法]を「BBoxセンターインサイド」に変更します。
シミュレーションを再生します。
ワークは最初のエッジが検出範囲に到達しましたが停止せずワークの中心が検出範囲に到達することで停止しました。
シミュレーションをリセットします。
[テスト方法]を「BBoxフリーインサイド」に変更します。
ワークが検出範囲に接触すると検知し停止します。
ボリュームセンサーはワークの検知をサンプリング間隔で指定した周期で実行しています。
[サンプリング時間]は0.01秒です。
[サンプリング使用]のチェックを外すことでパルスシグナルによりセンサーのオンオフを切り替えることができます。
ボリュームセンサーについての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

レイキャストセンサを使ってみよう

光学センサやレーザセンサ等を表現する方法
https://youtu.be/LRJE_kvuHlI
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_009.zip

レイキャストセンサーの説明をします。
eカタログの[タイプ別モデル]を展開し[Component Templates]をクリックします。
[Feeder Template]と[Conveyor Template]を3Dワールドに追加します。
コンベアを追加するとき自動的にフィーダーに接続されます。
シミュレーションを再生します。
フィーダーがワークを生成しワークがコンベアのパスに沿い移動することを確認します。
ワークを検出するためコンベアにレイキャストセンサーを追加します。
シミュレーションをリセットします。
コンベアを選択していることを確認し[モデリング]タブに移動します。
[動作設定]グループの[ビヘイビア]をクリックします。
[センサー]から[レイキャスト]を選択しレイキャストセンサーを追加します。
レイキャストセンサーのプロパティについて説明します。
レイキャストセンサの名前を定義することができます。
[親テスト]をチェックすることでセンサーと同じコンポーネントにあるジオメトリを検知することができますが、デフォルトではオプションはオフになっています。
3Dワールドで光線を表示することができますが、チェックを外し、非表示にします。
光線を照射するためサンプリングレートを使用することができ間隔を1ミリ秒に設定しています。
センサの範囲を定義しシグナル範囲で使用します。
[検出しきい値]はコンポーネントシグナルとブールシグナルで使用します。
設定を変更することで検出するものをパスなどのコンテナ内にあるワークに限定することができます。
[シグナル範囲]は、センサと検出したワークとの距離を測定することができ、[コンポーネントシグナル]はどのワークを検出したかを示し、[ブールシグナル]はセンサが検出したかを示します。
[フレーム]は3Dワールド内のセンサの位置を定義し、センサの光線はフレームの+Z軸方向に照射します。
プロパティについての説明は以上です。
センサの設定のためフレームを定義します。
3Dワールドにあるパスフレームを使用することもできます。
今回はパスフレームは使用しません。
[ジオメトリ]グループにある[フィーチャ]を展開し[フレーム]を追加します。
3Dワールドにフレームが表示されない場合、3Dワールドツールバーのフレームタイプをクリックし[フレーム]にチェックをつけます。
[移動]を使用しフレームをエッジの中間点に移動します。
フレームの向きに注意します。
[フィーチャプロパティ]でワールド座標であることを確認し、座標Rx,Ry,Rzが「0」であることを確認します。
フレームのZ軸が上を向いていますが、パスに沿い移動するワークを検出するため向きを変更します。
座標のオブジェクトをクリックし、座標Zを「50」、Rxを「-90」に設定します。
フレームを50mm上に移動し-90度回転させます。
センサはZ軸方向に光線を照射します。
[コンポーネントグラフ]でセンサを選択し[プロパティ]ウィンドウでフレームを定義します。
フレームの名前を変更するため、[コンポーネントグラフ]でフレームを選択します。
名前を「SensorFrame」に変更します。
センサに戻りセンサの最大範囲をコンベアの幅に合わせるため測定します。
[ツール]の[測定]をクリックします。
コンベアのエッジから反対側のエッジまでの距離を測定し、Y軸方向の距離が500mmであることがわかります。
センサの最大範囲を設定するためエスケープキーを押し測定モードを終了します。
センサの最大範囲を「500」に設定します。
[検出しきい値]はワークがコンベアの中央に沿い移動するため「250」に設定します。
約250mmの位置でワークを検出しますが、最大範囲での距離も検出します。
パス上のワークのみを検出するようにセンサを制限する場合、[検出コンテナ]にメインパスを設定します。
[検出コンテナ]は[コンポーネントグラフ]のワンウェイパスを参照しています。
[シグナル範囲]と[ブールシグナル]を設定するためにはシグナルを追加する必要があります。
ビヘイビアを展開しシグナルからブール型をクリックしブールシグナルを追加します。
同様に実数をクリックし実数シグナルを追加します。
コンポーネントをクリックしコンポーネントシグナルを追加します。
センサを選択します。
[シグナル範囲]に実数シグナルを設定し、検出するワークとの距離を取得します。
[コンポーネントシグナル]に作成したコンポーネントシグナルを設定し、[ブールシグナル]にはブールシグナルを設定します。
ワークを検出したときコンポーネントに指示を出すためPythonスクリプトを追加します。
ビヘイビアを展開しその他からPythonスクリプトを追加します。
エディタが自動的に開きます。
Pythonスクリプトを含むコンポーネントの情報を取得するため、「comp = getComponent()」と記述します。
getComponentはVC Scriptからインポートされており、Pythonスクリプトを含むコンポーネントの情報を取得することができます。
センサの変数を定義するため「sensor = comp.findBehaviour(" ")」と記述します。
名前を指定することでコンポーネントグラフのビヘイビアから情報を取得することができます。
レイキャストセンサの名前を入力します。
Pythonスクリプトの記述で検出コンテナにパスを設定することができます。
Pythonスクリプトでシグナルを使用する場合Pythonスクリプトとシグナルを接続する必要があります。
エディタを最小化し[コンポーネントグラフ]でブールシグナルを選択します。
[プロパティ]パネルで[接続]を展開し[+]ボタンをクリックします。
Pythonスクリプトをクリックすることでシグナルと接続することができます。
シグナルの値の変更をPythonスクリプトに送信します。
[×]ボタンで閉じます。
実数シグナルとコンポーネントシグナルも同様に接続するため、実数シグナルを選択しPythonスクリプトと接続します。
コンポーネントシグナルに対しても同様の設定をします。
シグナルはPythonスクリプトのトリガーとして使用します。
Pythonスクリプトをダブルクリックしエディタを開きます。
OnSignalに記述します。
if signal.Typeと記述します。
3つの異なるシグナルを使用しているためシグナルを指定します。
ワークとの距離を検知するリアルシグナルを指定するため、実数シグナルを示すVC_REALSIGNALと記述します。
検出したワークとの距離を[出力]ウィンドウに表示するため、print signal.Valueと記述します。
Pythonスクリプトをコンパイルしスクリプトを最小化します。
シミュレーションを再生します。
ワークが流れセンサが検出し[出力]ウィンドウに距離を表示しました。
シミュレーションを一時停止し[出力]ウィンドウを確認することで多くの情報を取得することができます。
ワークは平面ではないためセンサを通過するにつれ距離が変化しました。
最初は約242でしたが値は徐々に減少しているため、ワークがセンサまたは光線に徐々に接近しています。
ワークがセンサから離れ、値は徐々に元に戻ります。
[出力]ウィンドウをクリアします。
Pythonスクリプトに戻ります。
ワークとの距離が特定の値以下の場合、ワークまたはパスを停止します。
if signal.Value<=250:と記述します。
センサの検出コンテナを取得します。
sensor.DetectionContainer.Enabled=Falseと記述します。
ワンウェイパスの使用を無効にします。
検出したワークがセンサから250mm以内にある場合、パスの使用を無効にします。
Pythonスクリプトをコンパイルしますが、先にシミュレーションをリセットする必要があります。
シミュレーションを再生します。
センサがワークを検出しパスが停止しましたが、シミュレーションがまだ再生中です。
2つ目のワークはパス全体が無効であるため移動しません。
シミュレーションをリセットします。
Pythonスクリプトに戻りパスを無効にするのではなくワークを停止させます。
sesor.DetectionContainer.Enabled=Falseの先頭にハッシュタグを記述しコメントアウトします。
sensor.ComponentSignal.Value.stopMovementと記述します。
コンポーネントシグナルはコンポーネントを値として送受信することができます。
ワークを取得しstopMovementメソッドでワークを停止させます。
PythonスクリプトをコンパイルしPythonスクリプトを最小化します。
シミュレーションを再生します。
センサがワークを検出しパス全体ではなくワークを停止させました。
2つ目のワークがコンベア上を移動しています。
シミュレーションをリセットします。
Pythonスクリプトに戻ります。
OnSignalに記述してきましたが次はOnRunに記述します。
OnSignalの記述をコメントアウトします。
OnSignalを実行しないためpassと記述します。
OnRunではtriggerConditionを使用することができます。
triggerConditionは指定した式または関数がTRUEになるまでスクリプトの実行を遅延させます。
センサのシグナルをトリガに設定します。
lamda関数を使用しセンサのブールシグナルの値をテストします。
sensor.BoolSignal == Trueと記述します。
値がTRUEである場合、センサがワークを検出したことを示しているため、ワークを値として取得します。
part = sensor.ComponentSignal.Valueと記述します。
ワークを検出した場合ワークを停止させます。
OnSignalと行う動作は同じですがOnRunに記述する方法もあります。
Pythonスクリプトをコンパイルし Pythonスクリプトを最小化します。
シミュレーションを再生します。
ワークは停止しません。
シミュレーションをリセットしPythonスクリプトに戻ります。
triggerConditionでブールシグナル自体をテストしているためワークは停止しません。
ブールシグナルの値をテストします。
sensor.BoolSignal.Valueに変更する必要があります。
PythonスクリプトをコンパイルしPythonスクリプトを最小化します。
シミュレーションを再生します。
ワークを検出しワークを停止させました。
コンベアのパスは停止していません。
シミュレーションをリセットします。
サンプリングレートなしでセンサを使用する方法を説明します。
シミュレーションを再生するとき、センサは常にオンになっています。
コンポーネントに別のシグナルを追加し、パルスを使用しセンサをオンすることができます。
シミュレーションをリセットします。
ビヘイビアを展開し、任意のシグナルを使用することができますが、ブールシグナルを使用します。
名前を「PulseSignal」に変更します。
名前の変更は任意です。
レイキャストセンサーを選択します。
プロパティで[サンプリング使用]のチェックを外します。
パルスシグナルをセンサに接続する必要があります。
[コンポーネントグラフ]でパルスシグナルを選択します。
[プロパティ]で[接続]を展開し[+]ボタンをクリックしPythonスクリプトではなくレイキャストセンサと接続します。
パルスシグナルの値が変化するたびにセンサが動作します。
Pythonスクリプトを開きます。
OnSignalのpassを削除後、コメント アウトを元に戻し、OnRunの記述をすべてコメントアウトします。
センサのパルスを定義します。
アプリケーションオブジェクトを取得するためapp = getApplication()と記述します。
getApplicationはVC scriptからインポートされており、アプリケーションオブジェクトを取得します。
「pulse = comp.findBehaviour("PulseSignal")」と記述します。
whileループの下でシグナルメソッドを使用しパルスシグナルの値をTRUEに設定します。
シグナルを実行するたびパルスシグナルの値が変更または設定されセンサがオンになります。
シグナルの値を取得する頻度を設定します。
必要に応じdelay(0.1)と記述し、0.1秒遅延を発生させます。
OnSignalの記述ではシグナルがトリガとして使用されていますが、パルスシグナルがセンサをオンにしない限り、センサ内のシグナルは使用されません。
Pythonスクリプトをコンパイルし、シミュレーションを再生します。
ワークが停止しました。
シミュレーションをリセットし Pythonスクリプトに戻ります。
コンポーネントとレイキャストセンサがあります。
レイキャストセンサはシグナルを送信しない限りオンになりません。
パルスシグナルはシミュレーション再生中1ミリ秒ごとに送信します。
パルスシグナルを送信するとき、ワークを検出した後、停止します。
センサを1秒ごとにオンにする設定に変更します。
動作を確認します。
シミュレーションをリセットし、Pythonスクリプトをコンパイルします。
パルスを使用する場合、ワークを検出できない可能性があります。
Pythonスクリプトに記述したAPIを確認するため[ヘルプ]タブをクリックします。
PythonAPIをクリックしリファレンスガイドを開きます。
センサについての記述を確認するため「vcBehaviour」をクリックします。
Behavior Specific Propertiesをクリックし、Raycast Sensorを探します。
レイキャストセンサのプロパティが定義されています。
ブールシグナルにはブール型のシグナルを定義します。
「vcBoolSignal」をクリックすることで、ValueやSignal Methodを確認することができ、Signal Methodは値にシグナルを送信しシグナルの値を設定することができます。
アプリケーションオブジェクトを使用したため、「vcApplication」に移動し、「Properties」をクリックします。
シミュレーションオブジェクトにアクセスすることができるシミュレーションプロパティがあり、「IsRunning」は3Dワールドでシミュレーションを再生していることを確認することができます。
使用する全てのPythonスクリプトでvcScriptにあるメソッドをインポートします。
vcScriptに移動します。
アプリケーションオブジェクトやコンポーネントを取得することができます。
triggerConditionを使用し、条件がTrueであることを確認します。
レイキャストセンサについての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

ロボットツールを作って、製品を搬送しよう（1/2）

オリジナルのロボットツールを作成する方法（3DCADファイルをインポート、機構付け、動作設定）
https://youtu.be/TrLWWbdfRnM
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_055_p1.zip

ロボットツールの3DCADをインポートし、機構や動作を設定する方法を説明します。
動画内で使用するロボットツールの3DCADファイルをダウンロードします。
ファイル名は、[Gripper_2Finger_version2.SLDPRT]です。
[モデリング]タブを開きます。
[インポート]-[ジオメトリ]を選択します。
ダウンロードしたファイルを開きます。
[モデルをインポート]ウィンドウの[フィーチャツリー]-[最小化]を選択し、フィーチャツリーのジオメトリを1つのみ作成します。
[ジオメトリを整理]の[折りたたみ]を選択し、全てのメッシュを1つのジオメトリセットにまとめます。
ジオメトリセットは、フィーチャツリーの各ジオメトリの中に含まれるジオメトリのまとまりです。
メッシュを構成する三角ポリゴンの3点の合計が10000を超えると、新しいジオメトリセットが作成されます。
[上軸]は、[+Z]を選択します。
[インポート]を選択し、ロボットツールの3DCADをインポートします。
インポートしたモデルの三角ポリゴンの数を確認します。
[ジオメトリ]-[ツール]-[三角形を数える]を選択します。
[三角形を数える]ウィンドウの[有効なコンポーネント]を選択します。
[出力]ウィンドウに、三角形の数が表示されます。
Total triangle countに3767と表示されているため、三角形の数は3767個あるということがわかります。
数が多い場合は、不要なパーツのジオメトリを簡素化できますが、今回は適切な数のため、そのままとします。
ロボットツールをクリックし、ジオメトリを選択します。
右クリックし、[ツール]-[エクスプロード]を選択して、ジオメトリを分解します。
-X軸方向の爪部分を選択すると、爪が一本に分解されていることがわかります。
+X軸方向の爪部分を選択すると、爪と下の駆動台が一体化しているため、分解する必要があります。
右クリックし、[ツール]-[エクスプロード]を選択して、再度ジオメトリを分解します。
+X軸方向の爪部分を選択すると、爪が一本に分解されていることがわかります。
爪を開いたり閉じたりさせるために、動かしたい箇所を指定して、機構を設定します。
爪が選択された状態で、右クリックし、[抽出]-[抽出リンク]を選択します。
[コンポーネントグラフ]ウィンドウを確認すると、[Link_1]という名前のリンクが作成されていることがわかります。
このリンク設定により、稼働台と別れて、爪のみ動かせるようになりました。
-X軸方向の爪部分を選択します。
右クリックし、[抽出]-[抽出リンク]を選択します。
[コンポーネントグラフ]ウィンドウを確認すると、[Link_2]という名前のリンクが作成されていることがわかります。
[Link_1]を選択します。
[リンクプロパティ]ウィンドウに[JointType]という項目があります。
[JointType]は、[固定]、[回転]、[直進]、[回転フォロワー]、[変換フォロワー]、[カスタム]を選択できます。
デフォルトでは、「固定」が設定されています。
今回は、爪をX軸方向に直進運動させるため、[直進]を選択します。
[マニピュレーション]の[移動]が選択されている状態で、3Dワールドを確認すると、中心に小さい矢印があることがわかります。
中心の小さい矢印は、移動方向を表しています。
爪が、+Z軸方向に移動する設定になっているため、+X軸方向に変更します。
[リンクプロパティ]ウィンドウの[軸]を[+X]に変更します。
3Dワールドの矢印を確認すると、移動方向が、+X軸方向を向いていることがわかります。
爪の動きを制御する設定を追加します。
[リンクプロパティ]ウィンドウの[Controller]を[新規サーボコントローラ]に設定します。
Controllerが「サーボコントローラ」になります。
[コンポーネントグラフ]ウィンドウを確認すると、[ビヘイビア]に「サーボコントローラ」が作成されていることがわかります。
再び「Link_1」を選択します。
爪の可動域の最大値と最小値を設定します。
[最小リミット]は、0にします。
[最大リミット]は、デフォルト値の180のままにします。
「Link_2」の機構を設定します。
[コンポーネントグラフ]ウィンドウの「Link_2」を選択します。
[リンクプロパティ]の[JointType]を[変換フォロワー]にします。
[変換フォロワー]は、指定したジョイントの動きに追従します。
[ドライバー]をサーボコントローラのJ1にし、「Link_1」の爪の動きに追従するよう設定します。
[マニピュレーション]-[インタラクティブ]を選択し、「Link_1」の爪をX軸方向に動かすと、「Link_2」の爪が追従して動くことがわかります。
「Link_2」の爪が+Z軸方向に動いているため、-X軸方向に動くように設定します。
[マニピュレーション]-[移動]を選択します。
[リンクプロパティ]ウィンドウの[軸]を[-X]に変更します。
[マニピュレーション]-[インタラクティブ]を選択し、「Link_1」の爪をX軸方向に動かすと、「Link_2」の爪が-X軸方向に追従して動くことがわかります。
不要なコンポーネントが含まれているため、削除します。
ツールの中心にある小さい円柱を選択します。
Deleteキーを押す、[クリップボード]-[削除]を選択、もしくは、右クリックの削除を選択し、円柱を削除します。
同様に、3つの円柱を選択、削除します。
爪を開くと、2本の爪の間に細長いコンポーネントがあるため、選択し、削除します。
[ホーム]タブを開きます。
[マニピュレーション]-[インタラクティブ]を選択します。
爪を可動させたい端まで動かします。
[コンポーネントプロパティ]ウィンドウのJ1に、約30と表示されています。
爪の可動域の最大値は、約30ということがわかります。
爪の可動域の最大値を設定します。
シミュレーションをリセットします。
[モデリング]タブを開きます。
[コンポーネントグラフ]ウィンドウの「Link_1」を選択します。
[リンクプロパティ]ウィンドウの[最大リミット]を30にします。
[マニピュレーション]-[インタラクティブ]が選択された状態で、爪を動かすと、設定した最大値まで爪が動きます。
なお、[プログラム]-[リミット]-[リミットで停止]にチェックが入っていない場合、爪が可動域を超えた時に停止しません。
停止しない場合は、[リミットで停止]にチェックを入れてください。
マテリアルを設定します。
[コンポーネントグラフ]ウィンドウで、[Gripper_2Finger_version2]を選択します。
[ジオメトリ]-[ツール]-[マテリアル]-[割り当て]を選択します。
[マテリアルを割り当て]ウィンドウの[マテリアル]-[ライブラリ]を選択します。
[brass]を選択し、ツールの駆動台をクリックすると、真鍮のマテリアルが割り当てられます。
[ライブラリ]の[copper]を選択します。
ツールの爪をクリックすると、銅のマテリアルが割り当てられます。
[マテリアルを割り当て]ウィンドウを閉じます。
ツールの動作を設定します。
[コンポーネントグラフ]ウィンドウで、[Gripper_2Finger_version2]を選択します。
[追加]-[ウィザード]-[先端]を選択します。
[先端]は、ロボットツールの制御に必要な設定を自動追加します。
[先端]ウィンドウに[コントロール]という項目があり、爪をコントロールする方法を選択できます。
[先端]は、[None]、[IO]、[ExternalAxis]、[IO/ExternalAxis]を選択できます。
[None]は、動作が設定されません。
[IO]は、入出力信号で動作します。
[ExternalAxis]は、ロボットの外部軸で動作します。
[IO/ExternalAxis]は、IOとExternalAxisの両方で動作します。
今回は、[IO]を選択します。
[入力シグナル]で、シグナルの種類を選択できます。
[One Action Signal to Open/Close]は、1つのシグナルを使用し、Trueでは閉じる、Falseでは開くと定義します。
[Two Separate Signals to Open/Close]は、2つのシグナルを使用します。
1つめのシグナルで、Trueでは開く、Falseでは設定なし、2つめのシグナルで、Trueでは閉じる、Falseでは設定なしと定義します。
[Three Signals(Both Options Above)]は、3つのシグナルを使用し、前者2つの両方を定義します。
今回は、[One Action Signal to Open/Close]を選択します。
[J1:CurrentState]で、現在位置を定義します。
今回は、爪が閉じられた状態で定義するため、[closed]を選択します。
[J1:IN_Action_Port]で、ロボットから接続されているポートをデフォルトの100にします。
[J1:OUT_OpenState_Port]で、爪が開いている状態をロボットに出力します。
ポートはデフォルトの101にします。
[J1:OUT_ClosedState_Port]で、爪が閉じている状態をロボットに出力します。
ポートはデフォルトの102にします。
これにより、爪が開いているか閉じているかの状態をロボットに送信することができます。
[適用]を選択します。
[コンポーネントグラフ]ウィンドウのプロパティ、ビヘイビアを確認すると、複数の項目が追加されていることがわかります。
[ビヘイビア]の[EOAT_MountInterface]は、接続時のインターフェースを定義します。
[ToolContainer]は、ツールフレームを格納します。
ツールフレームは、ロボットツールの爪のように、物体が動作する際の中心位置を指定します。
[GripperLogic]は、爪を開閉するためのPythonスクリプトのロジックです。
[IN_J1_ACTION]、[OUT_J1_OpenState]、[OUT_J1_ClosedState]は、爪を開閉するための入出力信号です。
[ToolContainer]-[ツール]を展開します。
TCPを選択し、ロボットツールの爪が開閉するための軸を設定します。
[マニピュレーション]-[移動]を選択し、フレームを爪の間に配置します。
Z軸の矢印を+Z軸方向にドラッグし、左クリックを押したままの状態でShiftキーを押します。
整列したいターゲットを選択するマークが表示されるため、爪の窪みの部分に位置を合わせ、Shiftキーと左クリックを外します。
ロボットにロボットツールを取り付けるための軸を設定します。
[コンポーネントグラフ]ウィンドウのフィーチャツリーのルートノードの下に、MountFrameというフレームがあります。
MountFrameは、ロボットとロボットツールを接続するための軸です。
今回は、軸の位置はそのままにします。
[コンポーネントグラフ]ウィンドウのEOAT_MountInterfaceを選択します。
[プロパティ]ウィンドウの[セクション:RobotTool]を展開します。
[Hierarchyフィールド:Hierarchy]を開くと、MounFrameが設定されていることがわかります。
ロボットが親、ロボットツールが子になるため、[Parent]のチェックは外したままにします。
[ToolExportフィールド:TCP]を開くと、ToolContainerが設定されていることがわかります。
ロボットに接続したときに、設定をエクスポートします。
ロボットツールの3DCADをインポートし、機構や動作を設定する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットツールを作って、製品を搬送しよう（2/2）

オリジナルのロボットツールを作成する方法
（ロボットツールとロボットの接続、ロボットツールで製品を掴む、搬送する、離す）
https://youtu.be/H5eOp_EdfZ4
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_055_p2.zip

ロボットツールを作って、製品を搬送する方法を説明します。
ロボットツールをロボットアームに取り付け、製品を搬送できるように動作を設定します。
パート1で作成したロボットツール、もしくは、[Model a Gripper - Part2_before.vcmx]をダウンロードし、開きます。
eカタログの[タイプ別モデル]-[Robots]を展開します。
[Visual Components]をクリックします。
[Generic Articulated Robot]を追加します。
ロボットツールを選択します。
[マニピュレーション]の[PnP]を選択した状態で、ロボットアームにロボットツールをドラッグ＆ドロップし、接続します。
ロボットで搬送したい製品を追加します。
eカタログの[タイプ別モデル]-[Products and Containers]をクリックします。
[Lathe Comp 3]を追加します。
[マニピュレーション]-[移動]を選択し、製品の位置がロボットツールの下になるように移動します。
[プログラム]タブを開きます。
[マニピュレーション]の[ジョグ]を選択します。
ロボットを選択します。
Y軸の回転値が約0になるように回転し、ロボットツールの爪を-Y軸方向に向かせます。
アームの上部が少し上を向いているため、床と並行になるように-Z軸方向に動かします。
[ジョグ]ウィンドウの[ツール]で[TCP]を選択します。
ピンクの丸がロボットツールの先端に移動したことがわかります。
TCPは、ロボットツールが製品を掴む位置を決めるフレームです。
ロボットツールの爪の先端にTCPを設定したため、爪の先端で製品を掴むことができます。
動作などを設定する前に、リセットボタンを押してしまうと、[ツール]が[Null]に戻るため、[TCP]を選択した状態を保存します。
シミュレーションバーの歯車のアイコンをクリックします。
[状態の保存]をクリックし、[ツール]に[TCP]を選択した状態を保持します。
ロボットの動きを順番に設定します。
[プログラムエディタ]ウィンドウの[サブプログラム]-[Main]に[各軸補間ステートメント]を追加します。
[各軸補間ステートメント]は、ロボットの位置を記録し、軸に沿って順番に動かすことができます。
[ツール]-[スナップ]を選択し、製品上面の中心位置に、ロボットツールを合わせます。
ロボットツールを+Z軸方向に移動し、[直線補間ステートメント]を追加します。
[直線補間ステートメント]は、ロボットの位置を記録し、最短距離で順番に動かすことができます。
製品を掴むため、爪の開閉の動作を設定します。
爪を開閉するには、開閉する動作のシグナルを送る必要があります。
シグナルを設定する前に、ロボットツールにどのシグナルが使用されているのかを確認します。
シミュレーションをリセットし、ロボットを初期位置に戻します。
[接続]-[シグナル]を選択します。
ロボットをクリックすると、使用されているシグナルが表示されます。
PnPを使用したため、ロボットとロボットツールのシグナルが接続されています。
シグナルの動作はシミュレーション実行中に確認することができます。
シミュレーションを実行すると、指定した位置に沿ってロボットツールが移動します。
[サブプログラム]の[Main]に設定したプログラムが一通り実行されたため、シミュレーションは一時停止しています。
爪の開閉時のシグナルを確認するため、シミュレーションを再生します。
[IN_J1_Action]をクリックすると、爪を開閉させることができます。
アクションシグナルがFalseの場合は、爪が開きます。
アクションシグナルがTrueの場合は、爪が閉じます。
アクションシグナルは、ロボットの出力シグナルの100を使用しています。
爪を開くと、ロボットの入力シグナルに101が送信されます。
爪を閉じると、ロボットの入力シグナルに102が送信されます。
シミュレーションをリセットします。
シグナルを使用して、爪の開閉を設定します。
ロボットツールが製品の上に移動するまで、爪は閉じたまま動かさないようにするため、ロボットの出力シグナルの100をTrueにします。
[PTP P1 TCP]の後ろに、[セットバイナリ出力ステートメント]を追加します。
[ステートメントプロパティ]の[バイナリ出力ステートメント]を100にします。
[出力値]にチェックを入れて、Trueにします。
ロボットツールが製品の上に移動した後、爪を開くようにするため、ロボットの出力シグナルの100をFalseにします。
[LIN P2 TCP]の後ろに、[セットバイナリ出力ステートメント]を追加します。
[ステートメントプロパティ]の[バイナリ出力ステートメント]を100にします。
[出力値]にチェックは入れず、Falseにします。
次の動作に移る際に、ロボットツールが製品にぶつからないよう、爪が開ききるまで待機します。
爪が開く際に入力シグナルの101を送信するため、入力シグナルの101の送信が終わるまで、次の動作を待機するようにします。
[バイナリ入力待機ステートメント]を追加します。
[ステートメントプロパティ]ウィンドウの[入力ポート]を「101」にします。
[入力値]にチェックを入れて、Trueにします。
シミュレーションをリセットし、ロボットを初期位置に戻します。
シミュレーションを実行すると、ロボットが製品の上まで移動し、爪が開くまで待機します。
ロボットツールを製品まで移動させ、爪で掴む動作を設定します。
[マニピュレーション]-[ジョグ]が選択された状態で、爪が製品を掴める場所まで、-Z軸方向に移動します。
3Dワールドのビューを正面にし、位置を爪の位置を確認します。
正面からコンポーネントを見やすくするため、正投影表示をONにします。
[マニピュレーション]-[ジョグ]が選択された状態で、爪を閉じて製品を掴みます。
ロボットツールを選択し、[ジョグ]ウィンドウの[ジョイント]を確認すると、約25と入力されていることがわかります。
約25mmの位置でロボットツールが閉じるため、爪の閉じる位置を25mmに変更します。
[コンポーネントプロパティ]ウィンドウを選択し、[J1_ClosedValue]を25にします。
正投影モードをOFFにし、3Dワールドの視点を回転しながら、爪と製品の位置が問題ないか確認します。
位置が問題ない場合は、現在の位置にロボットツールを移動させるため、ロボットをクリックし、[直線補間ステートメント]を追加します。
爪が開いたまま製品に向かって-Z軸方向に進んだ後、製品を掴むため、ロボットの出力シグナルの100をTrueにします。
[セットバイナリ出力ステートメント]を追加します。
[ステートメントプロパティ]の[バイナリ出力ステートメント]を「100」にします。
[出力値]にチェックを入れて、Trueにします。
爪が閉じてから、次の動作に移るため、爪が閉じきるまで待機します。
爪が閉じる際に入力シグナルの102を送信するため、入力シグナルの102の送信が終わるまで、次の動作を待機するようにします。
[バイナリ入力待機ステートメント]を追加します。
[ステートメントプロパティ]ウィンドウの[入力ポート]を「102」にします。
[入力値]にチェックを入れて、Trueにします。
爪が閉じた後、製品を掴む動作を設定します。
製品を掴むため、コンポーネントに掴むことを示す出力シグナルを送信します。
[セットバイナリ出力ステートメント]を追加します。
[ステートメントプロパティ]の[バイナリ出力ステートメント]を1にします。
[出力値]にチェックを入れて、Trueにします。
製品を掴んだ後、持ち上げる動作を設定します。
[LIN P2 TCP]と同じ位置まで持ち上げるため、[LIN P2 TCP]をコピーします。
[Set OUT]の後ろに貼り付けます。
シミュレーションをリセットします。
シミュレーションを実行すると、ロボットツールが製品を掴んでいないことがわかります。
出力シグナルの1に対し、掴む動作の設定をしていないため、ロボットツールが製品を掴むことはできません。
出力シグナルの1に動作を設定します。
ロボットをクリックします。
[コンポーネントプロパティ]ウィンドウの[アクション設定]を展開します。
[シグナルアクション]が表示されるため、[出力]で1を選択します。
[オントゥルー]につかむ、[オンフォルス]にリリースがデフォルトで選択されているため、そのままにします。
[つかむ]の[使用ツール]は、爪の先端を使用して掴むため、[TCP]にします。
シミュレーションをリセットします。
シミュレーションを実行すると、ロボットツールが製品を掴んでいることがわかります。
ロボットツールが製品を掴んだ後、ロボットを初期位置に戻します。
[PTP P1 TCP]が初期位置のため、[PTP P1 TCP]をコピーします。
[LIN P4 TCP]の後ろに貼り付けます。
シミュレーションをリセットします。
シミュレーションを実行すると、ロボットツールが製品を掴み、初期位置に戻ります。
ロボットツールを作って、製品を搬送する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットツールを作って、PLCでロボットを制御して製品を搬送しよう(1/3)

オリジナルのロボットツールを作成する方法
（3DCADファイルをインポート、機構付け、動作設定、ロボットツールとロボットの接続）
https://youtu.be/k-smjeKC2VY
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_078_p1.zip

ロボットに接続するハンドの設定方法について説明します。
CADファイルをインポートします。
[ホーム]タブを選択し、[インポート]グループの[ジオメトリ]をクリックすることで、CADファイルをインポートできます。
[Gripper.3ds]を選択し、[開く]をクリックします。
[モデルをインポート]ウィンドウでは、インポート時のプロパティを設定できます。
[構造]は、単一のモデルをインポートする場合、[フィーチャ]か[ノード]を選択します。
レイアウトをインポートする場合、[コンポーネント]を選択します。
単一のモデルとしてインポートし、可動部を設定するため、階層構造はシンプルにする必要があります。
今回は、[フィーチャ]を選択します。
3Dワールドに表示されるモデルは、多数の三角形で構成されており、[テッセレーションの品質]は、三角形の個数を設定できます。
データ量の多いモデルの場合、低品質にすることで、データ量を削減できます。
今回はデータ量が少ないため、[中位品質]に設定します。
[含める]では、インポートするとき、ジオメトリに含む要素を設定できます。
今回は、[マークアップ]と[マテリアル]と[テクスチャー]を選択します。
[マテリアル作成ルール]では、マテリアルライブラリを作成するためのルールを設定できます。
今回は、[常にライブラリから最も近似のものを使用します]を選択します。
[フィーチャツリー]は、フィーチャツリーの作成方法を、設定できます。
[完全]は、CADファイルの階層構造をベースにし、すべてのジオメトリをトランスフォームフィーチャに入れ、フィーチャツリーを作成します。
CADファイルと完全に階層構造を一致させる場合、[完全]を選択します。
[最適化]は、すべてのジオメトリを同じ階層にし、[最小化]は、ジオメトリを1つにまとめることができます。
ハンドの可動部を設定するとき、フィーチャツリーをシンプルにするため、[最適化]を選択します。
[ジオメトリを整理]では、ジオメトリセットを作成するルールを設定できます。
ジオメトリセットは、フィーチャツリーの各ジオメトリの中に含まれるジオメトリのまとまりです。
メッシュを構成する三角ポリゴンの3点の合計が10000を超えると、新しいジオメトリセットが作成されます。
面ごとにジオメトリセットを作成する場合、[面による]を、マテリアルごとの場合、[マテリアルによる]を選択します。
ジオメトリセットを1つにまとめる場合、[折りたたみ]を、曲線のジオメトリセットを作成する場合、[数学的データ]を選択します。
今回は、[マテリアルによる]を選択します。
[上軸]は、ジオメトリの上面と底面を整列させる軸を設定できます。
[上軸]で[-X]を選択し、[インポート]をクリックします。
ハンドのCADファイルをインポートできます。
ハンドの可動部を設定するため、[モデリング]タブを開きます。
ワークをつかむため、ハンドには、2カ所の可動部があります。
ワークをつかむ部分の片側を選択します。
右クリックして、メニューを開きます。
[抽出]から[抽出リンク]を選択することで、選択したジオメトリを新しいノードに抽出できます。
[コンポーネントグラフ]ウィンドウに、「Link_1」が追加されたことがわかります。
同様に、ワークをつかむ部分の反対側も新しいノードに抽出します。
[コンポーネントグラフ]ウィンドウに、「Link_2」が追加されたことがわかります。
Link_1に動作の詳細を設定します。
[コンポーネントグラフ]ウィンドウで「Link_1」を選択します。
[リンクプロパティ]ウィンドウで[JointType]を設定することで、動作の種類を定義できます。
「固定」は、動作は設定せず、ノードを定義した位置に固定できます。
「回転」は、定義した軸を中心に回転運動、直進は、軸に沿って直線運動をします。
「回転フォロワー」は、別のノードの運動量に基づき、定義した軸を中心に回転運動、変換フォロワーは、直線運動することができます。
「カスタム」は、定義した軸を基準に、回転運動か直線運動することができます。
今回は、「直進」を選択します。
可動部が動作する方向を設定します。
[軸]で「+Y」を選択します。
可動部が動作する方向を確認します。
[マニピュレーション]グループの[インタラクティブ]を選択することで、可動部の動作を確認できます。
3Dワールドで「Link_1」をドラッグします。
「Link_1」が、Y軸方向に動作することがわかります。
シミュレーションのリセットボタンをクリックすることで、可動部が初期位置に戻ります。
[リンクプロパティ]ウィンドウの[Controller]は、ノードの動作を制御するコントローラーを定義できます。
[Controller]をクリックし、「新規サーボコントローラ」を選択します。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]を展開すると、サーボコントローラが追加されたことがわかります。
Geminiのサーボコントローラは、一般的なサーボコントローラとは異なり、可動部を制御する仮想のコントローラーです。
[リンクプロパティ]ウィンドウの[初期値]はノードの初期位置、[J1]はノードの現在位置を表示しています。
現在、[初期値]と[J1]は0です。
[最小リミット]と[最大リミット]は、ノードが動作できる範囲の最小値と最大値を定義できます。
[最小リミット]を「0」、[最大リミット]を「10」に設定します。
3Dワールドで「Link_1」をドラッグします。
「Link_1」が、[最小リミット]と[最大リミット]の範囲外に動作すると、[リンクプロパティ]ウィンドウの[J1]にエラーが発生します。
範囲外に動作しない設定にする場合、[プログラム]タブをクリックし、[リミット]グループの[リミットで停止]にチェックを付けます。
[モデリング]タブをクリックします。
3Dワールドで、「Link_1」をドラッグし、範囲外に動作しないことを確認します。
リセットボタンをクリックします。
Link_2に動作の詳細を設定します。
[コンポーネントグラフ]ウィンドウで「Link_2」を選択します。
ワークをつかむとき、「Link_2」は、「Link_1」の動作に連動し、「Link_1」とは反対方向に動作します。
[リンクプロパティ]ウィンドウで[JointType]を「変換フォロワー」、[軸]を「-Y」に設定します。
[ドライバー]は、動作を連動させるために参照する別のノードの運動量を設定します。
[ドライバー]をクリックし、サーボコントローラのJ1を選択します。
3Dワールドで、「Link_1」をドラッグします。
「Link_2」が、「Link_1」の動作に連動し、「Link_1」とは反対方向に動作することがわかります。
リセットボタンをクリックします。
ハンドに、ロボットとの接点や制御シグナルを設定します。
[コンポーネントグラフ]ウィンドウでGripperを選択します。
[追加]グループの[ウィザード]を展開し、[コンポーネントウィザード]から[先端]を選択します。
[先端]は、ロボットの先端として使用するために必要な設定を、選択したコンポーネントに、自動で追加できます。
[先端]ウィンドウの[コントロール]を設定することで、コンポーネントを制御する方法を定義します。
Noneは、コンポーネントを制御する設定は追加しません。
IOは、シグナルを使用して、コンポーネントの動作を制御するために必要な設定を追加します。
ExternalAxisは、ロボットとの接点と、ロボットの動作を設定するときに使用する基準点のみ、コンポーネントに追加します。
IO/ExternalAxisは、IOとExternalAxisの設定を両方追加し、どちらを使用するか選択することができます。
今回は、シグナルでハンドの動作を制御するため、IOを選択します。
[TCP]は、ロボットの動作を設定するときに使用する基準点です。
基準点を追加するため、[Add a Tool Center Point]を選択します。
[入力シグナル]は、動作を制御するシグナルの個数を定義できます。
2つのシグナルで、ハンドの開閉を制御するため、[Two Separate Signals to Open/Close]を選択します。
[J1]は、ハンドにシグナルで制御する設定を追加するかを選択できます。
シグナルで制御する設定を追加するため、チェックをつけます。
[J1:CurrentState]は、ハンドの現在の状態を設定できます。
現在、ハンドは開いているため、Openを選択します。
ハンドとロボットを接続したとき、ハンドのOpenとロボットのシグナル101、ハンドのCloseとロボットのシグナル102は、自動的に紐づけられます。
紐づけるシグナルを変更することもできます。
[適用]をクリックします。
[出力]ウィンドウには、ウィザードによる設定が完了したことと、ウィザードを閉じてよいことを示すメッセージが表示されます。
[閉じる]をクリックし、[先端]ウィンドウを閉じます。
[コンポーネントグラフ]ウィンドウに、自動追加された設定が表示されます。
[プロパティ]のJ1_OpenValueとJ1_ClosedValueは、ハンドが開き終わったときと、閉じ終わったときの位置です。
MotionTimeは、1回の動作にかかる時間を設定できます。
Control::AutoConnectIOsは、ロボットと接続したとき、シグナルを自動的に紐づけるかを設定できます。
残る4つのプロパティは、ハンドと自動的に紐づけるロボットのシグナルを指定します。
[ビヘイビア]のEOAT_MountInterfaceは、別の装置と接続するための設定です。
GripperLogicには、シグナルでハンドの動作を制御するプログラムが記述されています。
4つのブール型シグナルは、ロボットと接続するシグナルです。
ロボットに動作を設定するとき、移動先の座標を指定します。
ロボットに接続したハンドの先端を基準点とし、指定した座標に移動させることで、ロボットに動作を設定します。
ToolContainerと、ツールを展開します。
ウィザードが追加した点TCPを使用するため、ハンドの先端に移動します。
[ツールプロパティ]ウィンドウの座標Zに[現在の座標+95]と入力します。
現在の座標に95mm加算され、TCPはハンドの先端に移動します。
ハンドをロボットに接続します。
ロボットと接続する位置と向きは、[コンポーネントグラフ]ウィンドウのRoot[Gripper]にあるMountFrameで設定できます。
[ホーム]タブをクリックし、eカタログを表示します。
[タイプ別モデル]と、[Robots]を展開し、[Mitsubishi Electric]を選択します。
検索ボックスに、[RV-7FRLL]と入力します。
[RV-7FRLL]を、ダブルクリック、またはドラッグ＆ドロップすることで、3Dワールドに配置できます。
ハンドをロボットに接続するため、[マニピュレーション]グループの[PnP]を選択します。
ハンドを選択し、ロボットの先端にドラッグすることで、接続できます。
接続するハンドの向きを変更する場合、ロボットとハンドの接続を解除し、MountFrameの向きを変更します。
接続が完了すると、ロボットとハンドの間に表示されている三角形が、黄色から緑色に変化します。
[出力]ウィンドウに、ハンドのシグナルと、ロボットのシグナルが接続されたことを示すメッセージが表示されます。
[接続]グループの[シグナル]をクリックし、ロボットを選択することで、シグナルエディタが表示されます。
ハンドとロボットのシグナルは、自動的に紐づけられています。
ロボットの出力101がTrueの状態で、ハンドに送信されると、ハンドは開きます。
出力102がTrueの状態で、送信されると、ハンドは閉じます。
ハンドが開き終わったとき、ロボットの入力101をTrueにします。
ハンドが閉じ終わったとき、ロボットの入力102をTrueにします。
[プログラム]タブをクリックします。
ロボットを選択し、[マニピュレーション]グループの[ジョグ]をクリックします。
現在、ロボットの動作の基準点は、ロボットの先端にあるため、ハンドの先端に変更します。
[ジョグ]ウィンドウの[ツール]をクリックし、TCPを選択します。
動作の基準点がハンドの先端に移動したことがわかります。
この基準点の状態を保存します。
シミュレーションの設定ボタンをクリックし、[状態の保存]をクリックします。
再生ボタンをクリックすることでも、ロボットの現在の状態を保存できます。
保存をする前にリセットボタンをクリックすると、ロボットの動作の基準点は、リセットされて、ロボットの先端に戻ります。
[ジョグ]ウィンドウの[ツール]が、リセットされていないことを確認します。
TCPの位置から表示されている矢印、面、弧、丸をドラッグすることで、ロボットを動かすことができます。
ロボットに接続するハンドの設定方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットツールを作って、PLCでロボットを制御して製品を搬送しよう(2/3)

オリジナルのロボットツールを作成する方法
（ロボットのティーチング）
https://youtu.be/dc945nExKMg
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_078_p2.zip

ロボットに動作を設定する方法について説明します。
本動画は、ロボットに接続するハンドの設定方法の続きから設定します。
ハンドの設定が、完了しているファイル[Robot1_after.vcmx]が必要です。
ワークを持ち上げ、コンベアに置く動作を、ロボットに設定します。
本動画では、実際にワークをつかむ設定はせず、動作のみ設定します。
コンベアとワークを配置するため、[ホーム]タブをクリックします。
eカタログの[タイプ別モデル]から[Conveyors]を展開し、[Visual Components]を選択します。
Conveyorをダブルクリック、またはドラッグ＆ドロップで3Dワールドに追加します。
[Products and Containers]を展開し、[Visual Components]を選択します。
Cubeを3Dワールドに追加します。
ハンドでつかむため、Cubeの大きさを変更します。
[コンポーネントプロパティ]ウィンドウの[CubeLength]、[CubeWidth]、[CubeHeight]をすべて60mmに変更します。
ロボットからシグナルを送信することで、ハンドを開閉させます。
ロボットプログラムを設定するため、[プログラム]タブをクリックします。
[プログラムエディタ]ウィンドウの[サブプログラム]には、プログラムが設定されていないメインルーチンが表示されています。
シミュレーションを実行すると、メインルーチンのプログラムを上から順番に実行します。
今回は、サブルーチンを追加し、メインルーチンでサブルーチンを呼び出すことで動作を実行します。
ハンドを開くサブルーチンを作成します。
[サブプログラム]の[シーケンスを追加]をクリックすることで、サブルーチンが追加されます。
[サブプログラム]に、Sequence1が追加されたことがわかります。
[ルーチンプロパティ]ウィンドウで、[名前]をToolOpenに変更します。
ステートメントツールバーから、[セットバイナリ出力ステートメント]を選択します。
セットバイナリ出力ステートメントは、シグナル番号を指定し、シグナルの値を送信できます。
今回、ハンドを開くシグナルは101、ハンドを閉じるシグナルは102に設定してあります。
ハンドを開くため、シグナル101をTrueにします。
[ステートメントプロパティ]ウィンドウの[バイナリ出力ステートメント]で、シグナル番号を指定します。
[バイナリ出力ステートメント]を101に変更します。
[出力値]にチェックを付け、値をTrueに変更します。
ハンドを開くとき、ハンドを閉じるシグナル102は、Falseの状態にします。
[プログラムエディタ]ウィンドウのSet OUT[101]を選択します。
コピーして貼り付けます。
2つ目のSet OUT[101]を選択します。
[ステートメントプロパティ]ウィンドウの[バイナリ出力ステートメント]を102に変更し、[出力値]のチェックを外します。
シグナルを送信する前後に遅延を発生させ、処理の時間に猶予を持たせます。
[プログラムエディタ]ウィンドウの、ステートメントツールバーから、[遅延ステートメント]を選択します。
遅延ステートメントは、指定した秒数の遅延を発生させます。
[ステートメントプロパティ]ウィンドウで、[遅延]を1に変更します。
ロボットは、シグナル送信後、1秒待機します。
[プログラムエディタ]ウィンドウで、Delay 1sを選択します。
コピーして貼り付けます。
2つ目のDelay 1sをドラッグ＆ドロップで、Set OUT[101]の上に移動します。
ToolOpenをコピーし、編集することで、ハンドを閉じるサブルーチンを作成します。
ToolOpenを選択し、[サブプログラム]の[シーケンスをコピー]をクリックします。
[サブプログラム]に、ToolOpen1が追加されたことがわかります。
[ルーチンプロパティ]ウィンドウで、[名前]をToolCloseに変更します。
ToolCloseで送信するシグナル101と102の値を変更します。
ハンドを閉じるとき、シグナル101はFalse、102はTrueにします。
メインルーチンでサブルーチンを呼び出し、動作を確認します。
メインルーチンを選択します。
ステートメントツールバーから、[コールシーケンスステートメント]を選択します。
コールシーケンスステートメントは、特定のサブルーチンを呼び出し、実行することができます。
[ステートメントプロパティ]ウィンドウの[Routine]で、呼び出すサブルーチンを指定します。
ToolCloseを選択します。
同様に、[コールシーケンスステートメント]を追加し、ToolOpenを呼び出します。
シミュレーションを実行します。
ハンドが閉じ、遅延の後、再び開くことがわかります。
シミュレーションをリセットします。
ロボットに、ワークを持ち上げる動作を設定します。
ロボットには、動作の基準点があります。
[マニピュレーション]グループから[ジョグ]を選択すると、ピンク色の丸で表示されます。
ロボットに、基準点の移動先の座標を指定することで、動作を設定できます。
[プログラムエディタ]ウィンドウのメインルーチンを選択し、コールシーケンスステートメントを、すべて削除します。
ワークを持ち上げるサブルーチンを作成します。
[サブプログラム]の[シーケンスを追加]をクリックします。
名前をPickに変更します。
ハンドの先端に表示されているピンク色の丸をドラッグし、ロボットを移動させます。
[ツール]グループの[スナップ]を選択し、3Dワールドをクリックすることで、基準点をクリックした位置に移動できます。
ハンドがワークをつかむ位置に移動させるため、ワークの上面の中心をクリックします。
ハンドにワークの上半分をつかませるため、ハンドをおろします。
[ジョグ]ウィンドウの座標Zに[現在の座標-30]と入力します。
[プログラムエディタ]ウィンドウの、ステートメントツールバーから、[各軸補間ステートメント]を選択します。
各軸補間ステートメントは、ロボットに移動先の座標を指定できます。
座標に到達するまで、ロボットのノードの現在位置を補間することで、ロボットは動作します。
各軸補間ステートメントの名前はP1です。
ワークをつかむ前にワークに接近する位置と、ワークを持ち上げた時の位置を設定します。
Z軸方向の矢印を、ワークより上にドラッグします。
[プログラムエディタ]ウィンドウの、ステートメントツールバーから、[各軸補間ステートメント]を選択します。
Pickに、P2が追加されたことがわかります。
P2をコピーし、貼り付けます。
追加されたP3をドラッグ＆ドロップで、P1の上に移動します。
P1への移動後、ハンドを閉じるため、ToolCloseを呼び出します。
P1をクリックし、ステートメントツールバーから、[コールシーケンスステートメント]を選択します。
[ステートメントプロパティ]ウィンドウの[Routine]を、ToolCloseに変更します。
Pickを実行します。
[プログラムエディタ]ウィンドウで、メインルーチンを選択します。
ステートメントツールバーから、[コールシーケンスステートメント]を選択します。
[ステートメントプロパティ]ウィンドウの[Routine]を、Pickに変更します。
リセットボタンをクリックし、ロボットを初期状態に戻します。
シミュレーションを実行します。
ロボットはワークの位置まで移動し、ハンドを閉じ、持ち上げる動作をしたことがわかります。
ワークをつかむための設定をまだしていないため、ワークをつかむことはできません。
次の動画で説明します。
シミュレーションをリセットします。
ロボットに、ワークをコンベアに置く動作を設定します。
[プログラムエディタ]ウィンドウの[サブプログラム]から、[シーケンスを追加]を選択します。
名前をPlaceに変更します。
ワークを置く位置を設定します。
[ツール]グループの[スナップ]を選択し、コンベア上をクリックします。
このままワークを置くと、ワークがコンベアにめりこんでしまうため、ワークの底面がコンベアに接する位置に変更します。
[ジョグ]ウィンドウの座標Zに[現在の座標+30]と入力します。
[プログラムエディタ]ウィンドウの、ステートメントツールバーから、[各軸補間ステートメント]を選択します。
PlaceにP4が追加されたことがわかります。
ワークを置く前にコンベアに接近する位置と、ワークを置いた後の位置を設定します。
Z軸方向の矢印を上にドラッグします。
[プログラムエディタ]ウィンドウの、ステートメントツールバーから、[各軸補間ステートメント]を選択します。
PlaceにP5が追加されたことがわかります。
P5をコピーし、貼り付けます。
追加されたP6をドラッグ＆ドロップで、P4の上に移動します。
P4への移動後、ハンドを開くため、ToolOpenを呼び出します。
P4をクリックし、ステートメントツールバーから、[コールシーケンスステートメント]を選択します。
[ステートメントプロパティ]ウィンドウの[Routine]が、ToolOpenであることを確認します。
Placeを実行します。
[プログラムエディタ]ウィンドウで、メインルーチンを選択します。
ステートメントツールバーから、[コールシーケンスステートメント]を選択します。
[ステートメントプロパティ]ウィンドウの[Routine]を、Placeに変更します。
リセットボタンをクリックし、ロボットを初期状態に戻します。
シミュレーションを実行します。
ワークを持ち上げ、コンベアに置く動作をしたことがわかります。
ロボットに動作を設定する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットツールを作って、PLCでロボットを制御して製品を搬送しよう(3/3)

オリジナルのロボットツールを作成する方法
（ロボットツールで製品を掴む、搬送する、離す、PLCで制御する）
https://youtu.be/laxQNkUg5iA
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_078_p3.zip

ロボットでワークを搬送する方法について説明します。
本動画は、ロボットに動作を設定する方法の続きから設定します。
ロボットに動作が設定されているファイル[Robot2_after.vcmx]が必要です。
ロボットで、実際にワークをつかみます。
ロボットのシグナルを制御することで、コンポーネントをつかみ、放すことができます。
ロボットを選択します。
[コンポーネントプロパティ]ウィンドウの[アクション設定]を展開します。
シグナルアクションは、シグナルがTrueの時と、Falseの時に、アクションを設定できます。
[シグナルアクション]の[出力]は、シグナル番号を指定します。
eカタログに登録されているロボットの、[出力]1から64には、アクションがすでに設定されています。
今回は、未設定のシグナルにアクションを設定します。
[出力]をクリックし、65を選択します。
Trueのとき、つかみ、Falseのとき、放すため、[オントゥルー]でつかむ、[オンフォルス]でリリースを選択します。
つかむときの、コンポーネントを検出する範囲を設定します。
[つかむ]の[使用ツール]は、検出範囲の中心を定義するフレーム、[ボリュームサイズの検出]は、検出範囲のサイズです。
ハンドの先端から、XYZ軸方向に80mmを検出範囲とするため、[使用ツール]をTCP、[ボリュームサイズの検出]のXYZをすべて80に変更します。
放すときの、コンポーネントの置き場所を検出する範囲を設定します。
[リリース]の[重力の方向]は、つかんでいるコンポーネントの底面からの距離です。
底面から[重力の方向]までの範囲内にある、パスやコンテナにつかんでいるコンポーネントを格納します。
範囲内にパスやコンテナがない場合、3Dワールドにコンポーネントを放します。
今回は、10に変更します。
ハンドの開閉に、つかむ、リリースのシグナルアクションを追加します。
ハンドが開いたとき、シグナル65をFalseにすることで、ワークを放します。
[プログラムエディタ]ウィンドウの[サブプログラム]から、ToolOpenを選択します。
Set OUT[102]をコピーし、貼り付けます。
2つ目のSet Out[102]を選択します。
[ステートメントプロパティ]ウィンドウの[バイナリ出力ステートメント]を65に変更します。
ハンドが閉じたとき、シグナル65をTrueにすることで、ワークをつかみます。
ToolCloseを選択します。
Set OUT[102]をコピーし、貼り付けます。
2つ目のSet Out[102]を選択します。
[ステートメントプロパティ]ウィンドウの[バイナリ出力ステートメント]を65に変更します。
シミュレーションを実行します。
ロボットは、ワークを持ち上げ、コンベアに置いたことがわかります。
シミュレーションをリセットします。
ロボットが動作するタイミングをPLCから指示します。
[モデリング]タブをクリックします。
eカタログに登録されているロボットには、Inputs、Outputsという名前のシグナルマップが設定されています。
シグナルマップは、連続した番号のシグナルです。
ロボットは、シグナルマップで、PLCのデバイスから値を受信し、プログラムでトリガーとすることで、PLCの指示でプログラムを制御できます。
PLCに動作が完了したことを通知するため、プロパティを追加します。
[プロパティ]グループの[プロパティ]を展開し、[ベーシック]から[ブール型]を選択します。
プロパティは、コンポーネントのグローバル変数であり、ロボットの場合、サブプログラムのどのシーケンスからでも使用できます。
名前をX1に変更します。
同様に、ブール型プロパティを1つ追加します。
名前は、X2です。
X1は、Pickの動作が完了したとき、オンにします。
X2は、Placeの動作が完了したとき、オンにします。
指示するたびに動作を1回実行するため、実行したか判別する変数として使用するプロパティを追加します。
[プロパティ]グループの[プロパティ]を展開し、[ベーシック]から[ブール型]を選択します。
名前をcheck1に変更します。
同様に、ブール型プロパティを1つ追加します。
名前は、check2です。
[プログラム]タブをクリックします。
メインルーチンにループ処理を追加します。
[プログラムエディタ]ウィンドウの[サブプログラム]から、メインルーチンを選択します。
ステートメントツールバーから、[WHILEステートメント]を選択します。
WHILEステートメントは、条件がTrueの間、WHILEステートメントの範囲内にあるプログラムを、繰り返し実行します。
[ステートメントプロパティ]ウィンドウの[コンディション]で、条件を設定できます。
[コンディション]がTrueの場合、シミュレーション開始から終了まで、プログラムを繰り返し実行します。
Call Pickと、Call Placeを選択し、ドラッグ＆ドロップで、WHILEステートメントの範囲内に入れます。
処理の時間に猶予を持たせるため、ステートメントツールバーから[遅延ステートメント]を選択します。
ドラッグ＆ドロップで、WHILEステートメントの範囲内に入れます。
[ステートメントプロパティ]ウィンドウの[遅延]を1に変更します。
指示することで、Pickを実行するプログラムを追加します。
[プログラムエディタ]ウィンドウの[サブプログラム]から、[Pick]を選択します。
ロボットが動作する条件を設定します。
ステートメントツールバーから、[IFステートメント]を選択します。
IFステートメントは、条件を満たしているとき、実行するプログラムと、満たしていないとき、実行するプログラムを設定することができます。
シグナルマップInputsの1がTrueのとき、ロボットを動作させます。
[ステートメントプロパティ]ウィンドウの[コンディション]に、IN[1]==Trueと入力します。
1回指示すると、Pickを1回実行し、次に指示するまで待機するプログラムを追加します。
[プログラムエディタ]ウィンドウで、If IN[1]のThenを選択します。
ステートメントツールバーから、[IFステートメント]を選択します。
check1がTrueのとき、ロボットを動作させます。
[ステートメントプロパティ]ウィンドウの[コンディション]に、check1==Trueと入力します。
[プログラムエディタ]ウィンドウで、P3からP2までのステートメントを選択し、If check1のThenにドラッグ＆ドロップします。
PLCに動作完了を通知します。
ステートメントツールバーから、[変数割り当てステートメント]を選択します。
変数割り当てステートメントは、プロパティの値を設定できます。
[ステートメントプロパティ]ウィンドウの[ターゲットプロパティ]で、プロパティを指定します。
[ターゲットプロパティ]に、X1と入力します。
値を設定するため、[数式値]にTrueと入力します。
1回動作を完了すると、次に指示するまで待機させるため、check1をFalseに変更します。
[プログラムエディタ]ウィンドウのAssign X1=Trueをコピーし、貼り付けます。
[ステートメントプロパティ]ウィンドウの[ターゲットプロパティ]をcheck1、[数式値]をFalseに変更します。
Inputsの1がFalseのとき、再度動作を実行できるようにします。
[プログラムエディタ]ウィンドウのAssign X1=Trueと、Assign check1=Falseをコピーします。
if IN[1]のElseを選択し、貼り付けます。
X1をFalse、check1をTrueに設定します。
同様に、1回指示すると、Placeを1回実行するプログラムを追加します。
if IN[1]を選択し、コピーします。
Placeを選択し、貼り付けます。
P7からP9までのステートメントを削除します。
P6からP5までのステートメントをドラッグ＆ドロップで、Assign X1=Trueの上に移動します。
IN[1]をIN[2]に変更します。
check1をcheck2に変更します。
X1をX2に変更します。
PLCと接続します。
GX Works3で、ラダー回路[WorkPickUp.gx3]を起動します。
シミュレーションを開始します。
[デバッグ]をクリックし、[シミュレーション]から[シミュレーション開始]を選択します。
Geminiの画面を表示します。
[接続性]タブをクリックします。
[接続性]タブが表示されない場合、[ファイル]タブをクリックし、[オプション]の[アドオン]選択します。
[有効にする]をクリックし、[OK]を選択します。
接続性を有効にする場合、Geminiを再起動する必要があります。
[接続性コンフィグ]ウィンドウの[MITSUBISHI ELECTRIC FA]を選択し、右クリックでメニューを開きます。
[サーバを接続]を選択することで、[接続性コンフィグ]ウィンドウに新しく[サーバ]が追加されます。
接続するPLCと設定を一致させます。
[接続を編集]ウィンドウの[PC側I/F]は、GX Simulator3です。
[CPUシリーズ]をRCPU、[CPUタイプ]をR16に変更します。
Geminiと接続するデバイスの範囲を確保します。
先頭デバイスにX1、点数に2と入力します。
先頭デバイスにY1、点数に2と入力します。
[接続性をテスト]をクリックし、表示されている接続設定をテストします。
[適用]をクリックします。
GeminiとPLCを接続するため、[接続性コンフィグ]ウィンドウで、[サーバ]のアイコンをクリックします。
GeminiとPLCのデバイスのペアを作成します。
[サーバ]には、[シミュレーションからサーバへ]と[サーバからシミュレーションへ]があります。
シミュレーションはGemini、サーバはPLCを示しています。
GeminiからPLCへ送信するデバイスを設定するため、[シミュレーションからサーバへ]を選択し、右クリックでメニューを開きます。
[変数を追加]を選択することで、[変数ペア作成]ウィンドウが表示されます。
左側がGemini、右側がPLCのデバイスです。
Gemini側で、[RV-7FRLL]と、[コンポーネントプロパティ]を展開し、X1を選択します。
PLC側で、X1を展開し、X1を選択します。
[選択済みペア]をクリックすることで、デバイスのペアを作成できます。
同様に、Gemini側と、PLC側でX2を選択し、ペアを作成します。
PLCからGeminiへ送信するデバイスを設定するため、[接続性コンフィグ]ウィンドウの[サーバからシミュレーションへ]を選択します。
[変数ペア作成]ウィンドウの[グループへの追加]が、[サーバからシミュレーションへ]に変化します。
[変数ペア作成]ウィンドウの[次を含む]で、[シグナルマップ]にチェックを付け、一覧にシグナルマップの表示を追加します。
Gemini側で、[RV-7FRLL]と、[Inputs]を展開し、1を選択します。
PLC側で、Y1を展開し、Y1を選択します。
[選択済みペア]をクリックします。
同様に、[Inputs]の2とY2を選択し、ペアを作成します。
シミュレーションを実行します。
ラダー回路を表示します。
画面が書き込みモードの場合、F3キーを押し、モニターモードに切り替えます。
M1を選択し、シフトキーとエンターキーを同時に押すことでONにします。
Geminiの画面では、ロボットがワークを持ち上げたことがわかります。
ラダー回路のM2を選択し、シフトキーとエンターキーを同時に押します。
Geminiの画面では、ロボットがワークをコンベアに置いたことがわかります。
ロボットでワークを搬送する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットをPythonで制御しよう(1/3)

ロボットをパイソンスクリプト（Python）を用いて制御して、ルーチンの実行やティーチングを行う方法
https://youtu.be/Z_K2inn6sQM
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_109_p1.zip

ロボットをPythonで制御する方法を説明します。
シミュレーション中のロボットの動作をスクリプトで制御し、動作を記録して自動化します。
パート1では、ロボットを指定した位置まで移動させます。
eカタログの[タイプ別モデル]-[Robots]-[Mitsubishi Electric]を展開します。
[RV-13FL]を追加します。
ロボットの動きを設定します。
[プログラム]タブを開きます。
[マニピュレーション]-[ジョグ]が選択された状態で、ロボットを選択します。
[プログラムエディタ]ウィンドウの[サブプログラム]にある＋ボタンをクリックし、シーケンスを追加します。
名前をExampleに変更します。
[ジョグ]ウィンドウを開きます。
[座標]で[オブジェクト]を選択し、Y座標を500にします。
[サブプログラム]-[Example]に[各軸補完ステートメント]を追加します。
[各軸補間ステートメント]は、ロボットの位置を記録し、ジョイントの値を補間して動かすことができます。
[ジョグ]ウィンドウでY座標を-500にします。
[サブプログラム]-[Example]に[各軸補完ステートメント]を追加します。
サブプログラムのルーチンは、パイソンスクリプトに呼び出して使用することができます。
Exampleルーチンをパイソンスクリプトに呼び出し、シミュレーション実行中にロボットが動作するように設定します。
シミュレーションをリセットします。
[モデリング]タブを開きます。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
パイソンスクリプトダイアログが開きます。
今回は使用しないため、OnSignal関数は削除します。
OnRun内のpassを削除します。
comp = getComponent()と記述し、Pythonスクリプトを設定しているコンポーネントを取得します。
robot_executor = comp.findBehaviour("Executor")と記述し、ビヘイビアのExecutorを取得します。
Executorは、ロボットやサーボの実行プログラムです。
Mainルーチンを実行しないため、robot_executor.IsEnabled = Falseと記述します。
routine = robot_executor.Program.findRoutine("Example")と記述し、Exampleルーチンを取得します。
if routine:robot_executor.callRoutine(routine)と記述し、Exampleルーチンを取得したとき、Exampleルーチンを実行します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
Exampleルーチンが実行され、ロボットが動作します。
シミュレーションをリセットします。
ロボットのライブラリを使用して、Exampleルーチンをパイソンスクリプトに呼び出す方法もあります。
ロボットのライブラリには、ロボットを制御するときに便利なメソッドが含まれています。
パイソンスクリプトを開きます。
from vcHelpers.Robot2 import *と記述し、ロボットのライブラリを呼び出します。
OnRun内を削除します。
robot = getRobot()と記述し、ロボットの情報を取得します。
robot.callSubRoutine("Example")と記述し、Exampleルーチンを呼び出します。
callSubRoutineは、事前に定義されたロボットのプログラムを名前で呼び出します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
Exampleルーチンが実行され、ロボットが動作します。
シミュレーションをリセットします。
パイソンスクリプトのメソッドを使用して、ロボットの動作を制御します。
driveJointsメソッドでロボットのジョイントを指定した位置まで移動させた後、Exampleルーチンを呼び出します。
6行目にrobot.driveJointsと記述し、ロボットのジョイントを指定した目標値に移動します。
今回は、J1からJ3までのジョイントを0の位置に移動するため、0を記述します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ロボットのジョイントが0に移動した後、Exampleルーチンが実行され、ロボットが動作します。
シミュレーションをリセットします。
moveJointメソッドでロボットのジョイントを指定した位置まで移動させます。
7行目にrobot.Controller.moveJointと記述し、ロボットのジョイントをインデックス番号を使用して、指定した目標値に移動します。
動かしたいジョイントをLinkのインデックス番号で指定します。
J3を動かすため、2番目を指定します。
J3のジョイントを90の位置に移動するため、90.0を記述します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ロボットのジョイントが0から90に移動した後、Exampleルーチンが実行され、ロボットが動作します。
シミュレーションをリセットします。
ロボットをPythonで制御して、指定した位置まで移動させる方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットをPythonで制御しよう(2/3)

ロボットをパイソンスクリプト（Python）を用いて制御して、センサーと連携してワークを位置の把握・つかむ・運ぶ・リリースする方法
https://youtu.be/rmRg3Qxr6mI
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_109_p2.zip

ロボットをPythonで制御する方法を説明します。
パート1では、ロボットを指定した位置まで移動する方法を説明しました。
パート2では、ロボットで箱やワークをピッキングし、パレットに配置する方法を説明します。
パート1で使用したファイル、もしくは、[Control-Robots - Part1_after.vcmx]をダウンロードし、開きます。
箱を追加し、シミュレーション中に箱をピッキングします。
[ホーム]タブを開きます。
eカタログの[タイプ別モデル]-[Basic Shapes]を選択します。
[Block Geo]を追加します。
[マニピュレーション]-[PnP]が選択された状態で、箱がロボットの先端の下になるよう移動します。
ロボットを選択します。
[モデリング]タブを開きます。
パイソンスクリプトを開きます。
6行目以降を削除します。
OnRun内の最初の行にapp = getApplication()と記述し、アプリケーション情報を取得します。
part = app.findComponent("Block Geo")と記述し、箱の情報を取得します。
8行目にrobot.pickと記述し、ロボットが指定したコンポーネントをピッキングする動作を設定します。
箱をピッキングするため、partと記述します。
コンポーネントの矩形の境界のボックスを、バウンディングボックスといいます。
バウンディングボックスは、通常は表示されませんが、アタッチしようとすると赤い枠線で表示されます。
pickは、デフォルトでは、指定されたコンポーネントのバウンディングボックスの上面から掴みます。
コンポーネントのバウンディングボックスの上面の中心からZ軸プラス方向の距離200の地点に移動し、距離0の地点に下りて掴み、距離200の地点に戻ります。
今回は、300の距離で箱をピッキングするように指定するため、2つめの引数に300.0と記述します。
引数の詳細はヘルプの「vcHelpers.Robot2」のメソッド「pick」を参照してください。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ロボットが箱をピッキングします。
シミュレーションをリセットします。
[プログラム]タブを開きます。
[プログラムエディタ]ウィンドウを確認すると、[vcHelperJointMove]と[vcHelperLinearMove]が追加されています。
ロボットが箱に向かって移動する動作が、ルーチンとして自動で追加されていることがわかります。
別のコンポーネントからロボットを制御し、動いている部品をシミュレーション中にロボットでピッキングできます。
今回は、コンベヤからロボットを制御します。
ロボットと制御するコンベヤは、互いに接続されている必要はありません。
ワークがコンベヤ上のセンサーを通過したときに、ロボットがワークをピッキングするように設定します。
[ホーム]タブを開きます。
箱を選択し削除します。
eカタログの[タイプ別モデル]-[Feeders]を選択します。
[Basic Feeders]を追加します。
eカタログの[タイプ別モデル]-[Conveyors]-[Visual Components]を選択します。
[Sensor Conveyor]を追加します。
[マニピュレーション]-[PnP]が選択された状態で、フィーダーとコンベヤを接続します。
ロボットを選択します。
[コンポーネントプロパティ]ウィンドウの[WorkSpace]タブを開きます。
[Envelope]にチェックを入れると、ロボットの可動域が表示されます。
ロボットがセンサーラインに届くようにロボットの位置を調整します。
[Envelope]のチェックを外し、可動域を非表示にします。
パイソンスクリプトを作成し、センサーをトリガーとして、ロボットがワークをピッキングするように設定します。
コンベヤを選択します。
[モデリング]タブを開きます。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
パイソンスクリプトを閉じます。
センサーのトリガーを条件にスクリプトを処理したい場合は、センサーと紐づけたシグナルをパイソンスクリプトに接続します。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]-[SensorSignal]を選択します。
[プロパティ]ウィンドウの[接続]をクリックします。
プラスボタンが表示されるため、クリックすると、[Add 'Connections' items]ダイアログが表示されます。
[Python Script]を選択すると、[接続]に追加されたことがわかります。
[Add 'Connections' items]ダイアログを閉じます。
パイソンスクリプトを開きます。
今回は使用しないため、OnSignal関数を削除します。
from vcHelpers.Robot2 import *と記述し、ロボットのライブラリを呼び出します。
OnRun内のpassを削除します。
comp = getComponent()と記述し、コンポーネントの情報を取得します。
sensor_signal = comp.findBehaviour("SensorSignal")と記述し、ビヘイビアのSensorSignalを取得します。
triggerCondition(lambda: sensor_signal.Value != None)と記述し、センサーがNoneでない場合、つまり、センサーがワークを検知した場合に処理を実行します。
sensor_signal.Valueは、def文の関数で定義する必要がありますが、lambdaを記述することで、関数を省略できます。
part = sensor_signal.Valueと記述し、センサーの値を取得します。
センサーの値には、ワークの情報が格納されます。
app = getApplication()と記述し、アプリケーション情報を取得します。
robot_comp = app.findComponent("RV-13FL")と記述し、RV-13FLのロボットを探します。
robot = getRobot(robot_comp)と記述し、RV-13FLのロボットの情報を取得します。
robot.pickMovingPartと記述し、動いているコンポーネントをロボットでピッキングします。
pickMovingPartは、pickと同様に、コンポーネントのバウンディングボックスの上面から掴みますが、コンポーネントの速度に基づいて動作目標を計算して動くことができます。
センサーで検知したワークをピッキングするため、partと記述します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
コンベヤ上のセンサーがワークを検知すると、ロボットがワークをピッキングします。
シミュレーションをリセットします。
シミュレーション中にピッキングしたワークをパレットに配置します。
[ホーム]タブを開きます。
eカタログの[タイプ別モデル]-[Products and Containers]を選択します。
[Euro Pallet]を追加します。
ロボットがパレットに届くようにパレットの位置を調整します。
コンベヤを選択します。
[モデリング]タブを開きます。
パイソンスクリプトを開きます。
pallet = app.findComponent("Euro Pallet")と記述し、パレットの情報を取得します。
robot.placeと記述し、指定したコンポーネントにワークを配置します。
placeは、デフォルトでは、指定したコンポーネントのバウンディングボックスの上面の中心に、ワークのバウンディングボックスの底面の中心が着くように配置し、アタッチします。
パレットに配置するため、palletと記述します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ロボットがワークをピッキングした後、パレットに配置します。
シミュレーションを一時停止します。
パレットを移動すると、ワークも一緒に移動するため、ワークがパレットにアタッチされていることがわかります。
シミュレーションをリセットします。
ロボットをPythonで制御し、箱やワークをピッキングし、パレットに配置する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットをPythonで制御しよう(3/3)

ロボットをパイソンスクリプト（Python）を用いて制御して、自動生成したティーチングをルーチンに記録する方法と、ワークを複数並べる方法
https://youtu.be/VOIWos_7oOU
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_109_p3.zip

ロボットをPythonで制御する方法を説明します。
パート2では、ロボットで箱やワークをピッキングし、パレットに配置する方法を説明しました。
パート3では、ロボットでパレットからワークをピッキングする方法とロボットの一連の動作を自動化する方法を説明します。
パート2で使用したファイル、もしくは、[Control-Robots - Part2_after.vcmx]をダウンロードし、開きます。
シミュレーション中にパレットからワークをピッキングします。
パイソンスクリプトを開きます。
robot.pickFromPalletと記述し、指定したパレットからワークをピッキングします。
パレットからワークをピッキングするため、palletと記述します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ロボットがワークをピッキングした後、パレットに配置し、再度パレットからワークをピッキングします。
シミュレーションをリセットします。
シミュレーション中にロボットの動作をプログラムのルーチンとして記録し、自動化します。
コンベアを選択します。
[コンポーネントプロパティ]ウィンドウの[On Sensor]で[Stop Product]を選択します。
[Stop Product]は、センサーがワークを検知すると、ワークがセンサーの位置で止まります。
パイソンスクリプトを開きます。
ロボットがワークをピッキングする動作を記録します。
robot.RecordRoutineと記述し、ロボットの動作を記録します。
記録したルーチンは、PickPartという名前にします。
robot.RecordRSL = Trueと記述し、記録を開始します。
robot.pick(part)と記述し、センサーを検知したワークをピッキングします。
robot.RecordRSL = Falseと記述し、記録を終了します。
ロボットがワークをピッキングする動作を記録します。
robot.RecordRoutineと記述し、ロボットの動作を記録します。
記録したルーチンは、PlacePartという名前にします。
robot.RecordRSL = Trueと記述し、記録を開始します。
pallet = app.findComponent("Euro Pallet")と記述し、パレットの情報を取得します。
robot.place(pallet)と記述し、ワークをパレットに配置します。
robot.RecordRSL = Falseと記述し、記録を終了します。
robot.pickMovingPartからrobot.pickFromPalletまでは不要なため、＃を付けてコメントアウトします。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ロボットがワークをピッキングした後、パレットに配置します。
シミュレーションをリセットします。
[プログラム]タブを開きます。
[プログラムエディタ]ウィンドウを確認すると、サブプログラムにPickPartとPlacePartの2つのルーチンが追加されていることがわかります。
ルーチンの名前は、記録を開始する前に定義する必要があります。
同じ名前のルーチンが既にサブプログラムに存在する場合は、既存のルーチンのステートメントの後ろに記録が追加されます。
つまり、記録はルーチンに上書きされません。
シミュレーション中にロボットにパターンを指定して、ワークを配置します。
テーブルやパレット、コンベアの上に決まったパターンでワークを配置することができます。
[モデリング]タブを開きます。
パイソンスクリプトを開きます。
OnRun内のソースコードをコメントアウトします。
コメントアウトするには、アポストロフィーをコメントアウトしたいソースコードの最初と最後に3つずつ付けます。
ロボットの情報を取得するため、appからrobotまでをコピーし、OnRun内の最初の行に貼り付けます。
センサーをトリガーとして、ワークのピッキングを開始します。
compとsensor_signalをコピー＆ペーストし、ビヘイビアのSensorSignalを取得します。
ワークをパレットに8個配置します。
stack_size = 8と記述し、ワークをカウントするため、変数のstack_sizeに8を格納します。
while stack_size > 0:と記述し、0より大きいとき、つまり8個センサーで検知するまでループ処理します。
triggerConditionをコピー＆ペーストし、センサーがワークを検知した場合に処理を実行します。
partをコピー＆ペーストし、センサーの値を取得します。
robot.callSubRoutineと記述し、サブプログラムのルーチンを呼び出します。
ピッキングのルーチンを呼び出すため、PickPartと記述します。
palletをコピー&ペーストし、パレットの情報を取得します。
robot.placeInPatternと記述し、指定したパターンでロボットがワークを配置します。
ワークはパレットに配置するため、palletと記述します。
配置する位置をインデックス番号で定義します。
変数のx,y,zから2,2,2までの値を使用して、配置します。
x,y,zは0から開始するため、whileの上にx,y,z = 0,0,0と記述します。
stack_size -= 1と記述し、個数をカウントダウンします。
x,y,zのインデックス番号が、x=0,y=0,z=0からx=1,y=1,z=1になるように、8パターンの0と1の組み合わせで、値を格納します。
if x < 1:x += 1と記述し、xが1より小さいとき、xに1をプラスします。
else:x = 0 y+= 1と記述し、それ以外のとき、xを0にし、yに1をプラスします。
if y > 1:y = 0 z += 1と記述し、yが1より大きいとき、yを0にし、zに1をプラスします。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ロボットが1個目のワークをピッキングした後、パレットのx=0,y=0,z=0の位置に配置します。
ロボットが2個目のワークをピッキングした後、パレットのx=1,y=0,z=0の位置に配置します。
以降、指定したパターンに沿って、ロボットがワークを8個ピッキングし、パレットに配置します。
ロボットをPythonで制御し、ロボットでパレットからワークをピッキングする方法とロボットの一連の動作を自動化する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ワークの色を一部分のみ変更しよう

パイソンスクリプト（Python）を使用して、ワークの色を一部分のみ変更する方法
（関連動画：製品をハイライトして強調しよう、レイキャストセンサを使ってみよう）
https://youtu.be/L_5H7QXKt1M
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_178.zip

ワークの色を一部分のみ変更する方法について説明します。
ワーク全体の色を変更する方法は、動画「製品をハイライトして強調しよう」を参照ください。
事前ファイル「ChangeMaterial_before.vcmx」を開きます。
シミュレーションを実行します。
ワークが生成され、コンベア上を移動します。
ワークを生成し、コンベア上を移動させる方法は、動画「装置シミュレーション用コンベアを作ってみよう(1/3)」を参照ください。
ワークのrod部分のみ、色を変更します。
シミュレーションをリセットします。
PaintMachineにセンサーを設定します。
PaintMachineを選択し、[モデリング]タブを開きます。
センサーが検出する位置を設定するため、フレームを追加します。
フレームとは、3Dワールド上で、位置と方向を定義する基準点です。
[ジオメトリ]グループの[フィーチャ]を展開し、[その他]から[フレーム]を選択します。
3Dワールドに、フレームが表示されない場合、3Dワールドツールバーの[フレームタイプ]を展開し、フレームにチェックを付けます。
[フレームタイプ]アイコンが透明な場合、機能は無効となっているため、アイコンを選択し、有効にする必要があります。
3Dワールドに、フレームを表示できます。
[フィーチャプロパティ]ウィンドウで、[名前]をChangePositionに変更します。
フレームを移動させます。
ChangePositionを選択した状態で、[ツール]グループの[スナップ]を選択します。
[スナップ]は、選択しているものを、3Dワールドの選択した位置に移動できる機能です。
選択しているものの、原点を基準に移動できます。
PaintMachineの先端を選択します。
センサーの検出範囲を設定するため、ChangePositionからコンベアまでの距離を測定します。
[ツール]グループの[測定]を選択することで、3Dワールドで選択した2点間の距離を測定できます。
ChangePositionと、コンベアの上面を選択します。
2点間の距離が、3Dワールドと、[出力]ウィンドウに表示されます。
ワークを検出するため、センサーを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[センサー]から[レイキャスト]を選択します。
レイキャストセンサーは、定義したフレームの位置から光線を照射し、光線と交差したコンポーネントを検出できます。
センサーの位置を、フレームを選択して、定義します。
[プロパティ]ウィンドウの[フレーム]で、ChangePositionを選択します。
選択したフレームの+Z軸方向に光線は照射されます。
表示する光線の長さと、ワークを検出する範囲を設定します。
[最大範囲]は、センサーと、検出したコンポーネントとの距離を測定できる範囲です。
[シグナル範囲]で、実数型シグナルを定義することで、距離を出力できます。
今回、[シグナル範囲]は使用しませんが、3Dワールドに表示される光線の長さを変更するため、270と入力します。
コンベアを検出対象としないため、測定した距離より短く設定します。
[検出しきい値]は、コンポーネントを検出できる範囲です。
[検出しきい値]を270に変更します。
3Dワールド上の光線の表示/非表示は、[光線表示]で変更可能です。
検出したワークの情報を取得するため、[コンポーネントシグナル]を設定します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[コンポーネント]を選択します。
コンポーネントシグナルは、コンポーネントを値として送受信できるシグナルです。
[コンポーネントグラフ]ウィンドウの[RaycastSensor]を選択します。
[プロパティ]ウィンドウの[コンポーネントシグナル]でComponentSignalを選択します。
ワークの色を一部分のみ変更するため、PythonScriptを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
Pythonスクリプトエディタが自動的に開きます。
変更する色をマテリアルライブラリから取得するため、Geminiのアプリケーションにアクセスします。
app = getApplication()と記述します。
color = app.findMaterialと記述することで、マテリアルライブラリを参照できます。
カッコ内にyellowと記述し、名前が一致するマテリアルを参照します。
[ジオメトリ]グループ-[ツール]-[マテリアル]-[割り当て]を選択することで、マテリアルライブラリを確認できます。
シグナルの値が変化した時、処理を実行するため、関数OnSignalに記述します。
passを削除します。
関数OnSignalの引数signalには、PythonScriptに接続されたシグナルが入ります。
if signal.Value != None:と記述し、センサーが検出した時、以下の処理を実行します。
work = signal.Valueと記述し、変数workに、センサーが検出したコンポーネントを代入します。
feat = work.RootFeatureと記述することで、コンポーネントグラフウィンドウ下段のRootにアクセスできます。
Rootの子階層にあるフィーチャを取得するため、「.Children」と追記します。
目的のフィーチャを探すため、for i in feat:と記述し、フィーチャを1つずつ確認します。
フィーチャの名前がrodである場合、処理を実行するため、if i.Name == "rod":と記述します。
色を変更するフィーチャのタイプがジオメトリの場合、i.Geometry.GeometrySets[0].Materialと記述することで、マテリアルにアクセスできます。
フィーチャにマテリアルという設定項目がある場合、i.Materialと記述することでアクセスできます。
詳細は、[ヘルプ]タブ-[パイソンAPI]-[vcFeature]を参照ください。
「= color」と追記し、指定のマテリアルを設定します。
i.rebuild()と記述し、フィーチャを再構築します。
PythonScriptをコンパイルします。
PythonScriptとシグナルを接続します。
[コンポーネントグラフ]ウィンドウで、ComponentSignalを選択します。
[プロパティ]ウィンドウの[接続]、[+]アイコンを選択します。
[Add Connections items]ウィンドウで、PythonScriptを選択することで、接続できます。
シミュレーションを実行します。
ワークのrod部分のみ、黄色に変化していることがわかります。
しかし、次に生成されたワークも同時に色が変化しています。
コンポーネントクリエイターが生成している場合、すべてのワークが、フィーチャを共有しています。
コンポーネントをコピーした時も、同様です。
シミュレーションをリセットします。
ワークのテンプレートファイルを、再度設定する必要があります。
今回、ワークにはeカタログ-[タイプ別モデル]-[Products and Containers]のPiston Assyを使用しています。
右クリック、[メタデータを表示]を選択し、[VCID]をコピーします。
コンベアを選択し、[コンポーネントプロパティ]ウィンドウ-[ComponentCreator]タブの[パーツ]のVCIDを削除し、エンターキーを押します。
「vcid:」と入力し、先ほどコピーしたVCIDを貼り付けます。
PythonScriptで、色を変更する前に、フィーチャの共有を解除します。
変数workの代入後、work.makeUnique()と記述することで、フィーチャの共有を解除できます。
3Dワールドに配置されているコンポーネントの共有を解除する場合、コンポーネントを選択し、右クリック、[ツール]-[コンポーネント一意にする]を選択します。
PythonScriptをコンパイルします。
シミュレーションを実行します。
PainMachineを通過したワークのみ、色が変化していることがわかります。
シミュレーションをリセットします。
ワークの色を一部分のみ変更する方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

加工前と加工後で製品を置き換えてみよう

パイソンスクリプト（Python）を使用して、装置が加工した後に製品を別のコンポーネントに置き換える方法
https://youtu.be/nB1UpdvJ25I
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_064.zip

加工前と加工後で製品を置き換える方法を説明します。
あらかじめ動作が設定された装置のファイル開き、Pythonスクリプトでどのように製品を置き換えているかを確認します。
動画内で使用するGeminiのファイルをダウンロードします。
ファイル名は、[Replace Parts in Machines.vcmx]です。
シミュレーションを実行し、装置の動作を確認します。
製品がロボットに向かってコンベア上に流れます。
ロボットが製品をピックアップし、加工機に入れます。
加工を行った後、製品が加工前と異なる形状になります。
加工後の製品をロボットがピックアップし、コンベア上に流します。
この一連の流れが繰り返されるようになっています。
加工前と加工後で製品を置き換える動作は、Pythonスクリプトで設定しています。
また、使用している加工機は、eカタログの加工機をPythonスクリプトで改造しています。
シミュレーションをリセットし、Pythonスクリプトで製品を置き換える動作を確認します。
加工機をクリックします。
[モデリング]タブを開きます。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]を展開し、[PythonScript]を開きます。
179行目までスクロールします。
「ドアを開ける前に部品を交換する」という内容のコメントがあります。
次の行で、part = replacePart()という記述を追加しています。
replacePartという関数を呼び出していることがわかります。
212行目までスクロールします。
def replacePartと記述し、replacePartの関数を作成しています。
app = getApplication()と記述し、アプリケーション情報を取得します。
newpart = app.findComponent("LatheComp2")と記述し、3Dワールド上にあるLatheComp2を取得します。
LatheComp2は、加工後の製品として使用します。
newpart = app.cloneComponent(newpart)と記述し、LatheComp2を複製します。
oldpart = cont.Components[0]と記述し、contという変数で定義したコンポーネントを取得します。
contは、227行目のcont = comp.findBehaviour("ProcessContainer")で定義しています。
cont = comp.findBehaviour("ProcessContainer")で、加工機内にある加工前の製品情報を探します。
cont.grab(newpart)と記述し、加工後の製品であるLatheComp2を加工機内に入れます。
newpart.PositionMatrix = oldpart.PositionMatrixと記述し、加工機内の加工後の製品の位置と加工前の製品の位置を一致させます。
app.deleteComponent(oldpart)と記述し、加工前の製品を削除します。
return newpartと記述し、加工後の製品を返します。
180行目に戻ります。
return newpartで返した加工後の製品をpartの変数に割り当てます。
part変数は、加工機がロボットに製品をピックアップするようシグナルを送るために使用します。
実行をトレースボタンをクリックします。
実行をトレースを有効にすると、スクリプトの中でどの行が実行されているか確認できます。
シミュレーションを実行します。
装置の動作によって、スクリプトのプロセスが実行されていることがわかります。
加工前と加工後で製品を置き換える方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

可動部を斜めに動かそう

装置の可動部に、斜めの軸を設定し、直線、または回転運動の基準とする方法（移動モード、カスタム、Joint、Pivot、Pos、WPR）
https://youtu.be/cMWm-yv-iZI
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_179.zip

可動部を斜めに動かす方法について説明します。
MELSOFT Geminiでは、XYZ軸を基準に可動部を直線、または回転運動させることができます。
可動部を斜めに動かす場合、基準の軸を傾けさせる必要があります。
軸を傾けさせる方法を説明します。
CADファイルをインポートします。
[ホーム]タブ、または[モデリング]タブを開きます。
[インポート]グループの[ジオメトリ]を選択することで、CADファイルをインポートできます。
[Globe.3ds]を選択し、[開く]をクリックします。
[モデルをインポート]ウィンドウでは、インポート時の詳細を設定できます。
ジオメトリの階層構造をシンプルな状態にするため、[フィーチャツリー]で[最適化]を選択します。
ジオメトリの上面と底面を整列させる軸を設定するため、[上軸]で[-X]を選択します。
[インポート]をクリックします。
GlobeのCADファイルをインポートできたことがわかります。
可動部を設定するため、[モデリング]タブを開きます。
水色のブロックを選択します。
右クリック、[抽出]-[抽出リンク]を選択することで、ノードと呼ばれるかたまりとして抽出できます。
[コンポーネントグラフ]ウィンドウに、「Link_1」が追加されたことがわかります。
同様に白い四角錐と、緑色の四角錐を別のノードとして抽出します。
[コンポーネントグラフ]ウィンドウに、Link_2と「Link_3」が追加されたことがわかります。
動作の基準となる軸は、ノードの原点です。
「Link_2」の原点を回転させるため、[マニピュレーション]グループの[移動]を選択します。
[移動モード]の[ヒエラルキー]は、選択しているノードが階層構造になっている場合、親の影響を、子に与えます。
[選択済み]は、親の影響を子に与えません。
「Link_2」の原点のみ、回転させるため、[移動モード]を[選択済み]に変更します。
緑色の円弧をドラッグし、Y軸を中心に25度回転させます。
[リンクプロパティ]ウィンドウの[座標]を[オブジェクト]に変更することで、選択している対象の座標を表示できます。
[移動モード]を[ヒエラルキー]に変更します。
[リンクプロパティ]ウィンドウで、可動部に動作の詳細を設定します。
[JointType]で、直進を選択することで、動作の種類を直線運動に設定できます。
[軸]は、動作する方向です。
+X軸方向に動作させます。
「Link_2」の動作を確認します。
[マニピュレーション]グループの[インタラクティブ]を選択することで、可動部の動作を確認できます。
Y軸を中心に25度回転したX軸方向に、「Link_2」が動作していることがわかります。
シミュレーションのリセットボタンを選択することで、可動部を初期位置に戻すことができます。
[コンポーネントグラフ]ウィンドウで、「Link_3」を、Link_2にドラッグすることで、「Link_2」を親、「Link_3」を子とする階層構造を作成できます。
親の軸を回転、または移動させた場合、子は、親の座標を原点とし、元々の子の座標を加算します。
3Dワールドに表示されているモデルの位置を保持する場合、一度、元のコンポーネント、ノード、またはフィーチャにドラッグし、戻します。
「Link_3」の座標から「Link_2」の座標が引かれたことがわかります。
shiftキーを押した状態で、ドラッグし、親の座標を打ち消す座標を子に持たせ、3Dワールドの原点を基準とします。
3Dワールドに表示されているモデルの位置を保持した状態の、階層構造を作成できます。
「Link_1」の子が、「Link_2」、「Link_2」の子が、Link_3です。
[リンクプロパティ]ウィンドウの[Offset]に、Ry(-25)と入力され、「Link_2」の回転を打ち消しています。
意図していないジオメトリを抽出した場合、最初に、可動部が初期位置にあることを確認します。
次に、shiftキーを押した状態で、[コンポーネントグラフ]ウィンドウ下段から、上段のコンポーネント等にドラッグすることで、抽出する前の場所に戻すことができます。
JointTypeのカスタムを使用し、可動部を斜めに動かす方法を説明します。
「Link_3」を選択します。
[リンクプロパティ]ウィンドウの、[JointType]で、「カスタム」を選択します。
カスタムは、数式により、可動部の動作と軸の位置を定義できます。
[Joint]は、可動部の移動座標を定義できます。
[ヘルプ]タブ-[ヘルプ]-[式]で、MELSOFT Geminiでの数式の書き方を確認できます。
関数を使用し、移動座標を計算します。
Tx(100)と入力することで、「Link_3」を+X軸方向に100mm移動できます。
Txは、指定した距離だけX軸方向に移動した座標を計算する関数です。
カッコ内に定数を入力した場合、可動部は固定されます。
可動部として使用する場合、カッコ内にVALUEと入力します。
VALUEとは、[J2]に表示される「Link_3」の現在値です。
[Pivot]は、可動部の中心軸を定義できます。
Ry(25)と入力することで、中心軸をY軸を中心に25度回転させることができます。
Link_2と平行に、「Link_3」が動作していることがわかります。
シミュレーションのリセットボタンを選択します。
回転運動の中心軸を斜めに設定する方法を説明します。
[コンポーネントグラフ]ウィンドウで、「Link_1」を選択します。
[リンクプロパティ]ウィンドウの[JointType]で、カスタムを選択します。
[Joint]にRz(VALUE)と入力することで、Ｚ軸を中心に回転運動できます。
[Pivot]に関数Pos()を使用することで、中心軸のXYZ座標を指定できます。
[Pivot]にPos(200,300,0)と入力し、「Link_1」の原点から回転の中心軸が移動したことを確認します。
関数WPR()を使用することで、XYZ軸を中心とした回転角度を指定できます。
[Pivot]にWPR(0,25,0)と入力することで、Y軸を中心に25度回転したZ軸を回転の中心軸とします。
関数についての詳細は、[ヘルプ]-[式]-[関数]で確認できます。
3Dワールドで、「Link_1」をドラッグします。
灰色の円柱を中心に回転していることがわかります。
シミュレーションのリセットボタンを選択します。
可動部を斜めに動かす方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

減衰を使ってみよう(1/3)

物理の線形減衰と傾斜減衰を使用して、振動時の挙動を設定する方法
https://youtu.be/1Y5DTCICcl8
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_134_p1.zip

減衰を使用する方法を説明します。
減衰とは、摩擦や抵抗などによって運動のエネルギーが小さくなっていく効果のことです。
例えば、減衰がないと、ドアが速く閉まって部品が壊れたり、ドアが揺れて閉まらなくなる可能性があります。
減衰を使用することで、ドアがゆっくり閉まるように調整できます。
減衰には、線形減衰と傾斜減衰の2つの設定方法があります。
線形減衰を使用すると、任意の方向に動く物体を減速できます。
例えば、Y軸に沿って動く物体を減速できます。
傾斜減衰を使用すると、回転している物体を減速できます。
例えば、Z軸に沿って回転する物体を減速できます。
パート1では、三角柱や円柱を使用して、減衰の効果を確認します。
三角柱を作成し、減衰の効果を確認します。
eカタログの[タイプ別モデル]-[Physics]を開きます。
[Arrow Colider]を追加します。
[コンポーネントプロパティ]ウィンドウの[PhysicsEntity]タブを開きます。
[物理タイプ]を[物理内]に設定します。
[物理内]は、コンポーネントが重力や外部からの力の影響を受けます。
シミュレーションを実行します。
三角柱を持ち上げると、マウスカーソルを軸に振動し始めます。
床に落とすと、振動が止まります。
再度ゆっくり三角柱を持ち上げると、振動した後、その場で静止することがわかります。
シミュレーションをリセットします。
減衰の設定を確認します。
[モデリング]タブを開きます。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]-[PhysicsEntity]を選択します。
[プロパティ]ウィンドウを確認すると、線形減衰と傾斜減衰の項目があります。
線形減衰と傾斜減衰には、デフォルトで0が入力されています。
シミュレーションを実行します。
三角柱を持ち上げて動かすと、振動が止まるまでに時間がかかりますが、最終的には静止します。
シミュレーションをリセットします。
減衰を無効にします。
[線形減衰]と[傾斜減衰]を「-1」にします。
シミュレーションを実行します。
三角柱を持ち上げて動かすと、振動したまま、静止しません。
シミュレーションをリセットします。
減衰を最大値にします。
[線形減衰]を「1000」にします。
[傾斜減衰]を「400」にします。
シミュレーションを実行します。
三角柱を持ち上げて動かすと、ほとんど振動しません。
シミュレーションをリセットします。
線形減衰と[傾斜減衰]を「1」にします。
シミュレーションを実行します。
三角柱を持ち上げて動かすと、振動した後、揺れが小さくなり、最終的には静止します。
シミュレーションをリセットします。
円柱が倒れるときの軌道を表示し、減衰を可視化して確認します。
[ファイル]タブを開き、[全て消去]を選択します。
[ホーム]タブを開きます。
eカタログの[タイプ別モデル]-[Physics]を開きます。
[Cylinder Colider]を追加します。
[コンポーネントプロパティ]ウィンドウの[PhysicsEntity]タブを開きます。
[物理タイプ]を[物理内]にします。
円柱を積み上げます。
[ツール]-[パターン]を選択します。
[パターン]ウィンドウの[パターンに沿って]で「+Z」を選択します。
[カウント]を「8」にします。
[適用する]ボタンをクリックします。
シミュレーションを実行すると、円柱の振動が大きいため、崩れ落ちます。
シミュレーションをリセットします。
すべての円柱の線形減衰と傾斜減衰を変更できるようにします。
[モデリング]タブを開きます。
パイソンスクリプトを使用して、全ての円柱の物理エンティティを一括で制御します。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
3行目以降を削除します。
「app = getApplication()」と記述し、アプリケーション情報を取得します。
「cylinders = []」と記述し、リストを作成します。
「c for c in app.Components」と記述し、アプリケーションまたは3Dワールド上にあるコンポーネントをcという変数に代入します。
円柱を取得するため、if "Cylinder" in c.Nameと記述し、Cylinderという名前のコンポーネントをリストに格納します。
print len(cylinders)と記述し、円柱の個数を[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、8と表示されています。
円柱は8つあるため、円柱が全て取得できたことがわかります。
円柱を取得したことが確認できたため、print関数をコメントアウトします。
for c in cylinders:と記述し、円柱のリストをcという変数に代入します。
[PhysicsEntity]を選択し、[プロパティ]ウィンドウを確認すると、線形減衰と傾斜減衰の項目があります。
物理エンティティを取得し、減衰を設定します。
「b = c.getBehaviour("PhysicsEntity")」と記述し、円柱の物理エンティティを取得します。
「b.LinearDamping = 0」と記述し、[線形減衰]を「0」にします。
「b.AngularDamping = 0」と記述し、[傾斜減衰]を「0」にします。
コンパイルボタンをクリックします。
ロボットの信号を使用し、円柱を倒したときの軌跡を設定します。
[ホーム]タブを開きます。
eカタログの[タイプ別モデル]-[Robots]-[Mitsubishi Electric]を開きます。
[RV-13FL]を追加します。
[コンポーネントプロパティ]ウィンドウの[アクション設定]を展開します。
[シグナルアクション]が表示されるため、[出力]で81を選択します。
[RV-13FL]のシグナル81は、[オントゥルー]に掃引ボリュームオン、[オンフォルス]に掃引ボリュームオフがデフォルトで選択されています。
掃引ボリュームは、指定したジオメトリの軌跡を描画することができるため、デフォルトのままにします。
[掃引ボリュームオン]の[SweptGeometry]にロボットがデフォルトで選択されています。
SweptGeometryは、軌跡を描画したいジオメトリを指定できます。
ロボットではなく円柱の軌跡を可視化するため、ジオメトリを変更します。
入力エリアをクリックし、[RV-13FL]を削除します。
プラスボタンを選択します。
[Add 'SweptGeometry' items]ウィンドウが表示されるため、円柱を全て選択します。
[コンポーネントプロパティ]ウィンドウの[SweptGeometry]を確認すると、円柱が選択されたことがわかります。
[Add 'SweptGeometry' items]ウィンドウを閉じます。
[Material]で軌跡の色を変更します。
軌跡の色が分かりやすいよう、透明の色を使用します。
[transp_orange]を選択し、透明なオレンジ色にします。
[掃引ボリュームオフ]の[StoreGeometry]にチェックを入れ、シミュレーション中に作成した軌跡を保存します。
チェックを外すと、シミュレーションリセット時に軌跡が消えてしまうため、チェックを入れます。
ロボットのプログラムに設定した信号を使用し、軌跡を出力するための設定をします。
[プログラム]タブを開きます。
[マニピュレーション]-[ジョグ]が選択された状態で、ロボットを選択します。
[プログラムエディタ]ウィンドウの[サブプログラム]-[Main]に[セットバイナリ出力ステートメント]を追加します。
[ステートメントプロパティ]の[バイナリ出力ステートメント]に81を入力し、軌跡を可視化する信号を設定します。
[出力値]にチェックを入れて、Trueにします。
円柱の軌跡を10秒間表示するよう設定します。
[遅延ステートメント]を追加します。
[ステートメントプロパティ]ウィンドウの[遅延]に10を入力し、10秒間遅延させます。
[サブプログラム]-[Main]に[セットバイナリ出力ステートメント]を追加します。
[ステートメントプロパティ]の[バイナリ出力ステートメント]に「81」を入力し、軌跡を可視化する信号を設定します。
[出力値]にチェックは入れず、Falseにします。
シミュレーションを実行し、ロボットプログラムが終了するまで10秒間待機します。
プログラムの終了後、シミュレーションが停止します。
シミュレーションをリセットします。
新規コンポーネントとして軌跡が生成されたので、軌跡を比較するため、シミュレーションの妨げにならない位置に移動します。
軌跡を選択します。
[マニピュレーション]-[移動]を選択し、+Y軸方向に移動します。
軌跡を確認すると、下から3番目の円柱から倒れていることがわかります。
三角柱や円柱を使用して、減衰の効果を確認する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

減衰を使ってみよう(2/3)

物理の反復法ソルバーで位置反復と速度反復を使用して、振動時の挙動を設定する方法
https://youtu.be/aq4HJaVDunc
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_134_p2.zip

減衰を使用する方法を説明します。
パート1では、三角柱や円柱を使用して、減衰の効果を確認しました。
パート2では、円柱を使用して、減衰や反復法ソルバーの効果を確認します。
パート1で使用したファイル、もしくは、[Linear and Angular Damping_Part1_after.vcmx]をダウンロードし、開きます。
減衰の値を変更し、円柱の軌跡を確認します。
パイソンスクリプトを開きます。
[線形減衰]と[傾斜減衰]を「-1」にします。
コンパイルボタンをクリックします。
軌跡の違いをわかりやすくするため、軌跡の色を変更します。
ロボットを選択します。
[コンポーネントプロパティ]ウィンドウの[アクション設定]を展開します。
[シグナルアクション]が表示されるため、[出力]で81を選択します。
[Material]で[transp_blue]を選択し、軌跡の色を透明な青色に変更します。
シミュレーションを実行し、ロボットプログラムが終了するまで10秒間待機します。
シミュレーションをリセットします。
軌跡を選択し、+Y軸方向に移動します。
減衰が0の場合と同様に、下から3番目の円柱から倒れていることがわかります。
パイソンスクリプトを開きます。
減衰を最大値にします。
[線形減衰]を「1000」にします。
[傾斜減衰]を「400」にします。
コンパイルボタンをクリックします。
ロボットを選択します。
[コンポーネントプロパティ]ウィンドウの[アクション設定]を展開します。
[シグナルアクション]が表示されるため、[出力]で81を選択します。
[Material]で[transp_green]を選択し、軌跡の色を透明な緑色に変更します。
シミュレーションを実行し、ロボットプログラムが終了するまで10秒間待機します。
シミュレーションをリセットします。
軌跡を選択し、+Y軸方向に移動します。
減衰を最大値にした場合は、円柱が倒れず安定していることがわかります。
パイソンスクリプトを開きます。
減衰を最大値の半分にします。
[線形減衰]を「500」にします。
[傾斜減衰]を「200」にします。
コンパイルボタンをクリックします。
ロボットを選択します。
[コンポーネントプロパティ]ウィンドウの[アクション設定]を展開します。
[シグナルアクション]が表示されるため、[出力]で81を選択します。
[Material]で[transp_red]を選択し、軌跡の色を透明な赤色に変更します。
シミュレーションを実行し、ロボットプログラムが終了するまで10秒間待機します。
シミュレーションをリセットします。
軌跡を選択し、+Y軸方向に移動します。
減衰を最大値にした場合と同様に、円柱が倒れず安定していることがわかります。
パイソンスクリプトを開きます。
減衰の値を更に半分にします。
[線形減衰]を「250」にします。
[傾斜減衰]を「100」にします。
コンパイルボタンをクリックします。
シミュレーションを実行し、ロボットプログラムが終了するまで10秒間待機します。
シミュレーションをリセットします。
軌跡を選択し、+Y軸方向に移動します。
[線形減衰]を500、[傾斜減衰]を200にした場合と同様に、円柱が倒れず安定していることがわかります。
パイソンスクリプトを開きます。
減衰の値を更に半分にします。
[線形減衰]を「125」にします。
[傾斜減衰]を「50」にします。
コンパイルボタンをクリックします。
シミュレーションを実行し、ロボットプログラムが終了するまで10秒間待機します。
シミュレーションをリセットします。
軌跡を選択し、+Y軸方向に移動します。
[線形減衰]を250、[傾斜減衰]を100にした場合と同様に、円柱が倒れず安定していることがわかります。
パイソンスクリプトを開きます。
軌跡の変化が少ないため、減衰の値を小さくします。
[線形減衰]を15にします。
[傾斜減衰]を6にします。
コンパイルボタンをクリックします。
シミュレーションを実行し、ロボットプログラムが終了するまで10秒間待機します。
シミュレーションをリセットします。
軌跡を選択し、+Y軸方向に移動します。
[線形減衰]を125、[傾斜減衰]を50にした場合に比べ、全ての円柱が赤色になっています。
赤色も濃くなっているため、各円柱により多くの振動が発生していることがわかります。
パイソンスクリプトを開きます。
減衰の値を半分にします。
[線形減衰]を7にします。
[傾斜減衰]を3にします。
コンパイルボタンをクリックします。
シミュレーションを実行し、ロボットプログラムが終了するまで10秒間待機します。
シミュレーションをリセットします。
軌跡を選択し、+Y軸方向に移動します。
線形減衰が7、傾斜減衰が3のときに、円柱が倒れることがわかります。
減衰の代わりに反復法ソルバーを使用して、円柱の位置と速度を計算します。
反復法ソルバーとは、計算結果を仮定して、収束するまで反復計算を行い、正解の結果や近似値の結果を得るためのツールやアルゴリズムのことです。
減衰で使用する値がわからない場合や数値を何度も調整したくない場合は、反復法ソルバーを使用することで、円柱を安定させることができます。
パイソンスクリプトを開きます。
減衰を無効にします。
[線形減衰]と[傾斜減衰]を-1にします。
位置反復と速度反復を設定します。
円柱を選択します。
[モデリング]タブを開きます。
[コンポーネントグラフ]ウィンドウの[Cylinder Colider]-[ビヘイビア]-[PhysicsEntity]を開きます。
[プロパティ]ウィンドウを確認すると、[ソルバーポジションインテレーション]と[ソルバーベロシティインテレーション]の項目があります。
[ソルバーポジションインテレーション]と[ソルバーベロシティインテレーション]が反復法の設定項目のため、パイソンスクリプトで使用します。
パイソンスクリプトを開きます。
「b.SolverPositionIterations = 40」と記述し、位置反復を40にします。
「b.SolverVelocityIterations = 10」と記述し、速度反復を10回にします。
コンパイルボタンをクリックします。
[プログラム]タブを開きます。
ロボットを選択します。
[コンポーネントプロパティ]ウィンドウの[アクション設定]を展開します。
[シグナルアクション]が表示されるため、[出力]で81を選択します。
[Material]で[transp_yellow]を選択し、軌跡の色を透明な黄色に変更します。
シミュレーションを実行し、ロボットプログラムが終了するまで10秒間待機します。
シミュレーションをリセットします。
軌跡を選択し、+Y軸方向に移動します。
円柱が倒れず安定していることがわかります。
パイソンスクリプトを開きます。
反復法ソルバーの値を半分にします。
[位置反復]を「20」にします。
[速度反復]を「5」にします。
コンパイルボタンをクリックします。
シミュレーションを実行し、ロボットプログラムが終了するまで10秒間待機します。
シミュレーションをリセットします。
軌跡を選択し、+Y軸方向に移動します。
位置反復を40、速度反復を10にした場合に比べ、円柱の傾きが大きくなったことがわかります。
反復法ソルバーは位置や速度を計算するだけであり、円柱の動きを遅くさせることや外力に抵抗する力にはなりません。
円柱に外力を加える場合、減衰を使用すると、円柱の動きに対する制限や力を与えることができます。
シミュレーションを実行し、円柱に外力を与えると、円柱が倒れます。
円柱の動きを止めるために十分な抵抗や摩擦がないことがわかります。
10秒経過後、シミュレーションをリセットします。
軌跡を選択し、+Y軸方向に移動します。
パイソンスクリプトを開きます。
[線形減衰]を「20」にします。
[傾斜減衰]を「5」にします。
コンパイルボタンをクリックします。
シミュレーションを実行し、円柱に外力を与えます。
減衰がない場合に比べ、円柱が倒れにくく、安定していることがわかります。
シミュレーションをリセットします。
円柱を使用して、減衰や反復法ソルバーの効果を確認する方法は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

減衰を使ってみよう(3/3)

装置の一部に減衰を使用して、部品が衝突した時の挙動を設定する方法
https://youtu.be/8APKz3QOz5U
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_134_p3.zip

減衰を使用する方法を説明します。
パート2では、円柱を使用して、減衰や反復法ソルバーの効果を確認しました。
パート3では、コンベアを使用して、減衰の効果を確認します。
eカタログの[タイプ別モデル]-[Physics]を開きます。
[Conveyor (Physics)]と[Physics Feeder]を追加します。
[PnP]が選択された状態で、ダブルクリックして追加することで、フィーダーをコンベアに接続できます。
シミュレーションを実行すると、円柱がコンベア上に流れ、床に落ちます。
シミュレーションをリセットします。
コンベア上に流れる円柱を箱に変更します。
フィーダーを選択します。
[コンポーネントプロパティ]ウィンドウの[Product]で[EmptyBox]を選択します。
箱のサイズを変更します。
[ProductParams]タブを開きます。
[BoxHeight]、[BoxLength]、[BoxWidth]を100mmにします。
シミュレーションを実行すると、箱がコンベア上に流れます。
シミュレーションをリセットします。
箱の物理設定の干渉を変更します。
[PartPhysics]タブを開きます。
[AddColider]にチェックを入れると、[ColiderType]に[#Box]が表示されます。
箱が流れる頻度を減らします。
[既定]タブを開きます。
[CreationInterval]を4秒にします。
シミュレーションを実行すると、箱が4秒ごとにコンベア上に流れます。
シミュレーションをリセットします。
コンベア上に板を追加し、箱に衝突させます。
コンベアを選択します。
[モデリング]タブを開きます。
[構造]-[リンクをクリエイト]を選択します。
[マニピュレーション]-[移動]が選択された状態で、ピンク色の丸をコンベアのエッジにドラッグ&ドロップします。
[リンクプロパティ]のRx、Ry、Rzが0であることを確認します。
[ジオメトリ]-[フィーチャ]-[ブロック]を選択し、ブロックを作成します。
[フィーチャプロパティ]ウィンドウで長さを250mm、幅を10mmにします。
Rzを90にし、板を90度回転します。
[物理]を展開し、[干渉]を[box]に設定します。
[干渉]を[box]にすると、3Dワールド上には表示されませんが、コンベアの周りにボックスのようなものができます。
[出力]ウィンドウに「選択された干渉設定のために物理エンティティを追加しました。」と表示されます。
[コンポーネントグラフ]ウィンドウの[Physics Conveyor]-[ビヘイビア]を展開すると、物理エンティティが追加されたことがわかります。
板の色を変更します。
[ジオメトリ]-[ツール]-[マテリアル]-[割り当て]を選択します。
[マテリアルを割り当て]ウィンドウの[ライブラリ]タブを開きます。
[aquamarine]を選択し、板を選択します。
[マテリアルを割り当て]ウィンドウを閉じます。
シミュレーションを実行すると、箱が板に衝突します。
シミュレーションをリセットします。
箱が衝突すると、板が回転するように設定します。
コンベアのルートノードを選択します。
[動作設定]-[ビヘイビア]-[物理]-[ジョイント]を選択します。
[プロパティ]ウィンドウの[Parent]で[Link_1]を選択し、板にジョイントを取り付けます。
[Constraints]で、板を動かす際の、ジョイントの移動や回転に制約を付けます。
[Free]は、動作の制限がありません。
[Limited]は、動作の範囲を指定します。
[Locked]は、動作を固定します。
今回は、X軸を中心に板を回転させるため、[Twist Motion]、[Swing2 Motion]を[Locked]にします。
板の側面を中心に回転させるため、ジョイントの起点を移動します。
ピンク色の丸を板のエッジの中心にドラッグ＆ドロップします。
X軸を中心に回転させるため、Ryを90度回転します。
[PhysicsEntity]を選択します。
[プロパティ]ウィンドウの[物理タイプ]で、[物理内]を選択します。
シミュレーションを実行すると、箱が板に衝突した後、板が回り続けます。
シミュレーションをリセットします。
箱と衝突したあと、板が減速するように減衰を調整します。
[プロパティ]ウィンドウの[線形減衰]と[傾斜減衰]を「-1」にし、減衰を無効にした場合の動作を確認します。
シミュレーションを実行すると、減衰が0の場合と同様に、箱が板に衝突した後、板が回り続けます。
シミュレーションをリセットします。
[線形減衰]を「1000」、[傾斜減衰]を「400」にし、減衰を最大値にします。
シミュレーションを実行すると、箱が板に衝突した後、板が回り、静止します。
シミュレーションをリセットします。
板が回って静止した後、元の位置に戻るように設定します。
[PhysicsJointD6]を選択します。
[Swing1 Motion]で[Limited]を選択し、板が回る動作に制限をかけます。
[Swing Limits]を展開します。
[Swing Limit Y angle]を45度にします。
シミュレーションを実行すると、板が45度まで回転します。
シミュレーションをリセットします。
板が元の位置に戻らないため、他の項目を使用して戻るように設定します。
[Swing Limit Y angle]を0度にします。
[Swing Limit soft]にチェックを入れます。
デフォルトでは、[Swing Limit spring]に1、[Swing Limit damping]に0が入力されています。
シミュレーションを実行すると、箱が板に衝突した後、板が回り、元の位置に戻ります。
シミュレーションをリセットします。
板の戻り方が固いため、減衰を調整します。
[Swing Limit damping]を5にします。
シミュレーションを実行すると、箱が板に衝突した後、板が回り、ゆっくりと元の位置に戻ります。
シミュレーションをリセットします。
板が戻る時間が遅いため、スプリングを調整します。
[Swing Limit spring]を「0.5」にします。
シミュレーションを実行すると、箱が板に衝突した後、板が回り、ゆっくりと元の位置に戻ります。
シミュレーションをリセットします。
板が戻る時間が遅いため、減衰を調整します。
[Swing Limit damping]を0に戻します。
シミュレーションを実行すると、箱が板に衝突した後、板が回り、元の位置に戻ります。
シミュレーションをリセットします。
板の戻り方が少し固いため、物理エンティティの減衰を調整します。
[PhysicsEntity]を選択します。
[線形減衰]と[傾斜減衰]を0にします。
シミュレーションを実行すると、箱が板に衝突した後、板が回り、元の位置に戻ります。
板が戻るときに、振動が発生していることがわかります。
シミュレーションをリセットします。
振動が発生しないようにジョイントの減衰を調整します。
[PhysicsJointD6]を選択します。
[Swing Limit damping]を「2」にします。
シミュレーションを実行すると、箱が板に衝突した後、板が回り、少しゆっくりと元の位置に戻ります。
シミュレーションをリセットします。
板が戻る時間が少し遅いため、減衰を調整します。
[Swing Limit damping]を1にします。
シミュレーションを実行すると、箱が板に衝突した後、板が回り、程よい速度で元の位置に戻ります。
シミュレーションをリセットします。
箱が衝突すると、板がZ軸に沿って移動するように設定します。
[Swing1 Motion]を[Locked]にします。
[Ez Motion]を[Limited]にします。
シミュレーションを実行すると、箱が板に衝突した後、板が少し振動します。
シミュレーションをリセットします。
板の動作が固いため、制限の項目で調整します。
[Linear Limits]を展開し、[Linear Limit distance]を200mmにします。
シミュレーションを実行すると、デフォルト値と同様に、板が少し振動します。
シミュレーションをリセットします。
板の動作に変化がないため、復元力を調整します。
[Linear Limit restitution]を2にします。
シミュレーションを実行すると、箱が板に衝突した後、板が飛んでいきます。
シミュレーションをリセットします。
板が飛ばないようにします。
[Linear Limit distance]を0mmにします。
[Linear Limit extend]を200mmにして、板が復元する際の幅を持たせます。
シミュレーションを実行すると、板が大きく振動します。
シミュレーションをリセットします。
板の振動が大きすぎるため、復元力を小さくします。
[Linear Limit restitution]を1にします。
シミュレーションを実行すると、板が少し大きく振動します。
シミュレーションをリセットします。
板の振動をもう少し小さくするため、復元力を小さくします。
[Linear Limit restitution]を「0.5」にします。
シミュレーションを実行すると、板が元の位置にゆっくり戻ります。
復元力により、減衰が働いているため、ゆっくり戻ることがわかります。
シミュレーションをリセットします。
コンベアを使用して、減衰の効果を確認する方法は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

材料の密度を変更しよう

材料の密度を変更して、物体の質量に影響を与える方法
https://youtu.be/9eO2JZb4L2M
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_042.zip

材料の密度を変更する方法を説明します。
材料密度は、オブジェクトの質量に関係します。
動画内で使用するGeminiのファイルをダウンロードします。
ファイル名は、[Material Density - Layout.vcmx]です。
ファイルを開くと、Geminiにシーソーが表示されます。
シーソーの上には、同じ形状の2つの円柱があり、同じ質量、同じ密度を持っています。
シーソーは、2つの円柱の重さを比較して、左右の傾きで比較結果を表現できる作りになっています。
シミュレーションを実行すると、シーソーが右方向に倒れます。
Geminiでは、同じ質量、同じ密度を持っている場合、このファイルの配置だと、+Y軸方向に倒れます。
シーソーを-Y軸方向に倒す方法を説明します。
シミュレーションをリセットし、オブジェクトの形状を変更します。
右の円柱の大きさを左の円柱よりも小さくします。
これにより、右の円柱の質量が左の円柱よりも小さくなります。
[コンポーネントプロパティ]で、[CylinderHeight]を「200」から「50」に変更します。
シミュレーションを実行すると、シーソーが左方向に倒れることがわかります。
2つの円柱の密度が同じ場合でも、右の円柱の質量が小さいので、左方向に倒れます。
[CylinderHeight]を「50」から「200」に戻します。
円柱の大きさは変更せず、密度を変更します。
左の円柱を選択します。
[モデリング]タブを開きます。
[コンポーネントグラフ]ウィンドウで、[CylinderColider #2]-[ビヘイビア]-[PhysicsEntity]を選択します。
[プロパティ]ウィンドウの[物質密度]が、デフォルトで「0.2」に設定されています。
0.2という数値は、1立方メートルあたり0.2キログラムという意味を表します。
[物質密度]を「0.2」から「0.3」に変更します。
シミュレーションを実行します。
シーソーが左方向に倒れることがわかります。
密度を様々な設定に変更していきます。
[物質密度]を水の密度である「1000」に変更します。
シミュレーションを実行します。
シーソーが左方向に速く倒れることがわかります。
密度や質量の差が大きくなると、シーソーが倒れる速度が速くなります。
[物質密度]をアルミニウムの密度である「2700」に変更します。
シミュレーションを実行します。
シーソーが左方向に速く倒れることがわかります。
[物質密度]を鉛の密度である「11,000」に変更します。
シミュレーションを実行します。
同様の結果が表示されます。
右の円柱も同様の物質密度を設定します。
右の円柱を選択します。
[コンポーネントグラフ]ウィンドウで、[CylinderColider #3]-[ビヘイビア]-[PhysicsEntity]を選択します。
[物質密度]を「11,000」に変更します。
シミュレーションを実行します。
2つの円柱の密度が高すぎるため、梁が円柱の重量を支えきれなくなり、床に円柱が落下します。
梁が支えられる重量の上限は、梁や円柱の密度によって変化します。
梁の密度を上げることによって、2つの円柱を支えることができます。
このように、3Dワールドでオブジェクトを扱う場合、密度が与える影響を考慮する必要があります。
材料の密度を変更する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

参照型とリスト型のプロパティを作成しよう

パイソンスクリプト（Python）を使用して、コンポーネントのノードを参照できるプロパティと、リスト型のプロパティを作成する方法
https://youtu.be/qSzVYfU8BuY
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_073.zip

参照型とリスト型のプロパティを作成する方法を説明します。
ドロップダウンリストでロボットのノードを選択できるプロパティやAxisを表示するプロパティを作成します。
[モデリング]タブを開きます。
[コンポーネント]-[新規]を選択し、コンポーネントを作成します。
[ジオメトリ]-[フィーチャ]-[ブロック]を選択し、ブロックを作成します。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
パイソンスクリプトダイアログが開くため、デフォルトで記述されているソースコードを1行目以外削除します。
comp = getComponent()と記述し、Pythonスクリプトを設定しているコンポーネントを取得します。
prop = comp.getProperty("Test_RefNode")と記述し、プロパティのTest_RefNodeを取得します。
if not prop: prop = comp.createProperty()と記述し、プロパティが存在しない場合、プロパティを作成します。
参照型のプロパティを作成するため、Refと記述します。
参照型は、コンポーネント、ノード、フィーチャなどにアクセスでき、ドロップダウンリストで選択できます。
今回は、ノードを参照するため、タグ内にNodeと記述します。
プロパティの名前は"Test_RefNode"とします。
コンパイルボタンをクリックします。
[コンポーネントグラフ]ウィンドウのプロパティの表示がオンになっていることを確認します。
プロパティを展開すると、Test_RefNodeが追加されていることがわかります。
Test_RefNodeには、nullが割り当てられています。
ブロックから他のコンポーネントのノードを参照するため、ロボットを追加します。
[ホーム]タブを開きます。
eカタログの[タイプ別モデル]-[Robots]を展開します。
[Visual Conponents]をクリックします。
[Generic Articulated Robot]を追加します。
ブロックを選択します。
[コンポーネントプロパティ]ウィンドウを確認すると、[Test_RefNode]が表示されます。
ドロップダウンリストを開くと、3Dワールド上で使用可能な全てのリストが表示されます。
ドロップダウンリストの選択肢の中から、ノードを選択することができます。
ドロップダウンリストの横のアイコンを選択し、3Dワールド上のコンポーネントをクリックして選択することもできます。
アイコンをクリックします。
3Dワールドにマウスポインターを移動させると、選択できるノードを示す赤い境界線のボックスが表示されます。
ロボットのAxis2を選択します。
[コンポーネントプロパティ]ウィンドウの[Test_RefNode]を確認すると、ロボットのAxis2が選択されたことがわかります。
参照型プロパティを使用し、リストのプロパティを作成します。
画面左下のPythonスクリプトのウィンドウを開きます。
prop_list = comp.getProperty("Test_ListRefNode")と記述し、プロパティのTest_ListRefNodeを取得します。
if not prop_list:prop_list = comp.createProperty()と記述し、リストのプロパティが存在しない場合、プロパティを作成します。
リスト型のプロパティを作成するため、Listと記述します。
参照型プロパティを使用してリストを作成するため、タグ内にRefとNodeを記述します。
プロパティの名前は"Test_ListRefNode"とします。
プロパティに表示するノードのリストを作成します。
app = getApplication()と記述し、アプリケーション情報を取得します。
robot = app.findComponent("Generic Articulated Robot")と記述し、コンポーネントのGeneric Articulated Robotを取得します。
node_list = [robot.findNode("Axis 2"), robot.findNode("Axis 4")]と記述し、ノードのAxis2と4を取得します。
prop_list.Value = node_listと記述し、プロパティのリストにAxis2と4を割り当てます。
コンパイルボタンをクリックします。
[コンポーネント]グラフウィンドウを確認すると、[Test_ListRefNode]が追加されていることがわかります。
[Test_ListRefNode]には、Axis2と4が入力されています。
参照型とリスト型のプロパティを作成する方法は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

[出力]ウィンドウのメッセージを削除や保存しよう

パイソンスクリプト（Python）を使用して[出力]ウィンドウのメッセージをクリアや保存する方法
https://youtu.be/em70ROLqPHc

Python APIを使用して[出力]ウィンドウのメッセージを削除や保存する方法を説明します。
Geminiのアプリケーション内に削除と保存ボタンを作成し、実行することで、[出力]ウィンドウのメッセージを削除や保存できるようにします。
テキストエディタを開き、コマンドファイルを作成します。
コマンドファイルとは、Geminiのアプリケーション内にボタンなどを作成し、様々なイベントを実行できるようにするPythonファイルです。
ここでは、メモ帳を使用します。
from vcCommand import *と記述し、Geminiのコマンドファイルを呼び出します。
cmd = getCommand()と記述し、コマンドを取得します。
コマンドを取得することで、ボタンなどをGeminiに追加することができます。
app = getApplication()と記述し、アプリケーション情報を取得します。
アプリケーション情報を取得することで、[出力]ウィンドウのメッセージなどを取得できます。
メッセージを削除するためのボタンを作成します。
btnClear = cmd.createProperty()と記述し、プロパティを作成します。
ボタンタイプのプロパティを作成するので、VC_BUTTONと記述します。
ボタンに表示する文字は"Clear Messages"とします。
作成したボタンをクリックすると、[出力]ウィンドウのメッセージが削除されるよう定義します。
btnClear.OnChanged = clearMessagesと記述し、clearMessagesという関数を呼び出します。
def clearMessagesと記述し、clearMessagesの関数を作成します。
引数はpropとします。
app.clearMessages()と記述し、[出力]ウィンドウのメッセージの履歴を削除します。
メッセージを削除するメソッドは、Geminiのアプリケーション内に予め用意されています。
メッセージを保存するためのボタンを作成します。
btnSave = cmd.createProperty()と記述し、プロパティを作成します。
ボタンタイプのプロパティを作成したいので、VC_BUTTONと記述します。
ボタンに表示する文字は"Save Messages"とします。
作成したボタンをクリックすると、[出力]ウィンドウのメッセージが保存されるよう定義します。
btnSave.OnChanged = saveMessagesと記述し、saveMessagesという関数を呼び出します。
def saveMessagesと記述し、saveMessagesの関数を作成します。
引数はpropとします。
msg = app.getMessages()と記述し、[出力]ウィンドウのメッセージを取得します。
メッセージは文字列として取得します。
メッセージを保存するためのファイルのURIまたはパスを定義します。
uri = r""と記述し、文字列リテラルを作成します。
文字列リテラルとは、ソースコードに直接記述する、単語や文章などの文字列のことを言います。
保存先のパスをコピーするため、フォルダを開きます。
今回は、[ドキュメント]-[MITSUBISHI]-[Gemini]-[1.45]に保存します。
フォルダの[1.45]は[Gemini]のバージョンによって異なります。
今回は、GeminiのVer.1.45を使用するため、[1.45]に保存します。
パスをコピーし、メモ帳に貼り付けます。
パスの後ろに、保存する際のファイル名を記述します。
今回は、output.txtとします。
定義した保存先に、取得したメッセージを記述します。
with構文を使用し、ファイルを開く、取得したメッセージを書き込む、ファイルを閉じる、という一連の流れを自動で行います。
with open() as :と記述し、変数名はfileの頭文字を取ってfとします。
ファイル名をuri、操作モードを「a」とします。
「a」を指定すると、追記モードでファイルが開かれます。
f.write(msg)と記述し、ファイルの末尾に取得したメッセージが追記されるように指定します。
with構文では、ファイルを閉じる操作が組み込まれているので、ファイルを閉じる記述は不要です。
コマンドの初期状態を定義します。
def first_stateと記述し、first_stateの関数を作成します。
executeInActionPanel()と記述し、アクションウィンドウを実行します。
アクションウィンドウでのコマンド実行は、Geminiのアプリケーション内に予め用意されているPython APIです。
コマンドには、削除と保存のボタンがあり、アクションウィンドウに表示します。
この2つのボタンをクリックすると、削除または保存のアクションを実行できます。
addState()と記述し、first_state関数をコマンドとして追加します。
これで、コマンドファイルの作成は完了です。
ファイルを保存します。
今回は、[ドキュメント]-[MITSUBISHI]-[Gemini]-[1.45]-[My Commands]に保存します。
ファイル名を[messageHelper]、拡張子をPythonファイルの[.py]にし、保存します。
コマンドの初期化ファイルを作成します。
Geminiにコマンドを登録するには、初期化ファイルの作成が必要です。
ファイルを新規作成します。
from vcApplication import *と記述し、Geminiのプロパティやメソッドを呼び出します。
def OnStartと記述し、OnStartの関数を作成します。
cmduri = getApplicationPath() + "messageHelper.py"と記述し、URIを作成します。
cmd = loadCommand()と記述し、Geminiにコマンドを読み込みます。
1番目の引数はmessageHelper、2番目の引数はcmduriとします。
messageHelperはコマンドに付与するIDで、スクリプトの他の場所やローカライズするときに参照できるようにします。
cmduriは、コマンドのURIを指定します。
addMenuItem()と記述し、Geminiのユーザインターフェースにコマンドを追加します。
コマンド追加のメソッドは、Geminiのアプリケーション内に予め用意されています。
コマンドをGeminiのホームに追加するため、VcTabHomeと記述し、Testというグループを作成します。
VcTabHomeとTestの間は、「/」であり、「\」では動作しないため、ご注意ください。
参照IDは、messageHelperとします。
コマンドの表示位置をリストの後ろから1番目である-1に指定します。
コマンドの表示名をmessageHelperとします。
これで、コマンドの初期化ファイルの作成は完了です。
ファイルを[My Commands]に保存します。
ファイル名を[init]にします。
ファイル名の前後には、必ずアンダースコアを2つ付けます。
拡張子をPythonファイルの[.py]にし、保存します。
GeminiのVer.1.45を起動します。
[出力]ウィンドウで、Pythonのエラーメッセージがないことを確認します。
[ホーム]タブのコマンドメニューを確認します。
testグループとmessageHelperが作成されていることが分かります。
コマンドを右クリックして、クイックアクセスツールバーに追加します。
[出力]ウィンドウにメッセージを表示させるため、コンポーネントを追加します。
[モデリング]タブの[コンポーネント]-[新規]を選択し、コンポーネントを作成します。
[ジオメトリ]-[フィーチャ]-[ブロック]を選択し、ブロックを作成します。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
パイソンスクリプトダイアログが開くので、デフォルトで記述されているソースコードを1行目以外削除します。
print "Hello World"と記述し、[出力]ウィンドウにHello Worldを表示します。
コンパイルボタンをクリックすると、[出力]ウィンドウにHello Worldが表示されていることがわかります。
コマンドを実行します。
クイックアクセスツールバーのmessageHelperをクリックします。
アクションウィンドウに、Clear MessagesとSave Messagesボタンのプロパティが追加されます。
Clear Messagesボタンをクリックします。
[出力]ウィンドウのHello Worldが削除されていることがわかります。
再度、[出力]ウィンドウにメッセージを表示します。
同じソースコードをコンパイルできないため、行を一行追加します。
コンパイルボタンをクリックすると、[出力]ウィンドウにHello Worldが表示されます。
[出力]ウィンドウのメッセージを保存します。
アクションウィンドウのSave Messagesボタンをクリックします。
ドキュメントフォルダを開き、ファイルにメッセージが保存されたことを確認します。
[ドキュメント]-[MITSUBISHI]-[Gemini]-[1.45]を開きます。
ouput.txtが作成されていることがわかります。
ファイルを開きます。
Hello Worldのメッセージが保存されています。
ファイルを閉じます。
Geminiを開き、再度コマンドを実行します。
print関数を削除します。
def OnRun()と記述し、OnRunの関数を作成します。
for i in range(5)と記述し、変数のiを0から4の5つの数値に指定します。
print iと記述し、変数のi、つまり、0から4の数値を出力します。
コンパイルボタンをクリックします。
Clear Messagesボタンをクリックし、[出力]ウィンドウのメッセージを削除します。
シミュレーションを実行し、リセットします。
[出力]ウィンドウに0から4の5つの数値が表示されていることがわかります。
output.txtファイルに数値を追加します。
Save Messagesボタンをクリックします。
[ドキュメント]フォルダの[1.45]を開きます。
output.txtファイルを開きます。
ファイルに0から4の数値が追記されていることがわかります。
なお、お客様が独自に作成し、pyファイルで追加したメニューは、Geminiの標準機能ではないため、動作の保証はできかねます。
あらかじめご了承ください。
Python APIを使用して[出力]ウィンドウのメッセージを削除や保存する方法は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

水平方向の機構を持ったロボットを作ってみよう

オリジナルの、水平方向の機構を持った、単純な線形ロボットを作る方法
https://youtu.be/RSBj9Q6JY88
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_035.zip

eカタログのモデルを参照し直角座標ロボットをモデル化する方法を説明します。
[ホーム]タブを選択します。
eカタログの[タイプ別モデル]を展開しComponent Templatesを選択します。
「Template 3-Axis Cartesian」を ダブルクリックもしくはドラッグアンドドロップで3Dワールドに配置します。
ロボットがワールド原点にあることを確認します。
コンポーネントプロパティの座標と角度の値を0に設定することで原点に移動することができます。
テンプレートロボットにはXYおよびZ座標方向に直線運動する3つのリンクがあります。
テンプレートロボットの配置が完了しましたのでモデル化するロボットをインポートします。
[ホーム]タブまたは[モデリング]タブのインポートグループにある[ジオメトリ]をクリックします。
「ExampleCartesianGeometry.step」ファイルを選択し[開く]をクリックします。
[インポート]をクリックしモデルを読み込みます。
インポートしたモデルは簡略化されています。
オリジナルのジオメトリをインポートする場合はジオメトリの簡略化を実施し、モデルをシミュレーション用に軽量化することを推奨しています。
インポートしたジオメトリとテンプレートロボットを一体化します。
[モデリング]タブに移動しインポートしたジオメトリフィーチャを選択します。
フィーチャツリーからgeocontainer0を選択します。
選択されたジオメトリフィーチャは、3Dワールドで緑色にハイライトします。
フィーチャツリーまたは3Dワールドで右、クリックからコピーをクリックしフィーチャをコピーします。
テンプレートロボットのルートを選択し右クリックから[貼り付け]を選択します。
ルートの下に「GeoContainer_0」が複製されたことを確認します。
インポートしたコンポーネントと、テンプレートロボットに属する既存のジオメトリフィーチャをすべて削除します。
ジオメトリフィーチャが一体化しているため、個々に独立したジオメトリフィーチャとなるように分割します。
ジオメトリフィーチャの分解はエクスプロード機能を使用します。
分解するジオメトリフィーチャを選択し右クリックの[ツール]から[エクスプロード]を選択します。
ジオメトリフィーチャが分解されたことを確認します。
複雑なモデルでは必要に応じてジオメトリフィーチャを複数回エクスプロードし、より細かな部品単位に分割する必要がある場合があります。
可動部のジオメトリフィーチャをリンクに移動するため、グループ化を実施します。
4本の足と2本のビームを除く可動部すべてのジオメトリフィーチャを選択します。
フィーチャツリーもしくは3Dワールドで直接ジオメトリフィーチャを選択します。
複数のジオメトリフィーチャを選択する場合は、コントロールキーを押しながら選択します。
矩形選択を行う場合は、選択もしくはコントロールキーを押しながら3Dワールドでドラッグします。
全ての可動部品を選択すると、選択したジオメトリフィーチャが緑色にハイライトします。
右クリックのツールから[グループ]を選択し、ジオメトリフィーチャをグループ化します。
フィーチャツリーを確認しますと、トランスフォームフィーチャが生成されグループ化されたことが確認できます。
グループ化するとジオメトリフィーチャをまとめてリンクに移動できます。
生成されたトランスフォームフィーチャを選択し、「L1_X_Trans」にドラッグアンドドロップで移動します。
リンクから別のリンクにフィーチャを移動する場合、フィーチャは親座表形に対して相対的に移動します。
3Dワールドでジオメトリの位置を保持するためには、シフトキーを押しながらフィーチャをリンクにドラッグアンドドロップします。
「L1_X_Trans」は+X軸方向に移動する変換ジョイントで構成されています。
ジオメトリフィーチャが「L1_X_Trans」に移動できましたので、可動部品が全て動作することを確認します。
インタラクティブを選択し、「L1_X_Trans」を左クリックをドラッグすることで、X軸方向に動かします。
可動部品がすべて動作していることを確認します。
動作しない可動部品がある場合はジオメトリフィーチャを選択し、リンクにドラッグアンドドロップすることにより移動できます。
同様にY軸方向に動作するジオメトリフィーチャをグループ化し、「L2_Y_Trans」に移動します。
「L2_Y_Trans」は+Y軸方向に動作する変換ジョイントで構成されています。
フィーチャツリーもしくは3DワールドでY軸方向に動作するジオメトリフィーチャを選択します。
選択が完了しましたら右クリックのツールからグループを選択し、ジオメトリフィーチャをグループ化します。
フィーチャツリーを確認しますと、トランスフォームフィーチャが生成され、グループ化されたことが確認できます。
生成されたトランスフォームフィーチャを、ドラッグアンドドロップで「L2_Y_Trans」に移動します。
インタラクティブを使用し「L2_Y_Trans」をY軸方向に動かします。
Y軸方向の可動部品が全て動作していることを確認します。
同様にZ軸方向に動作するジオメトリフィーチャをグループ化し「L3_Z_Trans」に移動します。
「L3_Z_Trans」は+Z軸方向に動作する変換ジョイントで構成されています。
フィーチャツリーもしくは3Dワールドで+Z軸方向に動作するジオメトリフィーチャを選択します。
選択が完了しましたら右クリックのツールからグループを選択しジオメトリフィーチャをグループ化します。
フィーチャツリーを確認しますとトランスフォームフィーチャが生成され、グループ化されたことが確認できます。
生成されたトランスフォームフィーチャをドラッグアンドドロップでL3Zトランスに移動します。
インタラクティブを使用しL3ZトランスをZ軸方向に動かします。
Z軸方向の稼働部品が全て動作していることを確認します。
各リンクの中心点はジョイントの動作中心を定義しています。
作成した直角座標ロボットには3つのジョイントがありますが、各ジョイントは直線運動に設定されているため中心点の変更は必要ありません。
回転運動が設定されている場合リンク原点を中心に回転動作するため、正確な位置に設定する必要があります。
プレートの原点をエンドエフェクターとなる位置に移動します。
リンク原点を移動する方法は、[移動モード]グループを[選択済み]に設定し[ツール]グループからスナップを選択します。
L3Zトランスの先端中心をクリックし 原点を移動します。
同様にマウントプレートのフィーチャツリーにあるフランジフレームフィーチャもエンドエフェクターの位置に移動します。
[移動モード]グループをヒエラルキーに戻します。
シミュレーションバーのリセットをクリックすることでロボットのエンドエフェクターの位置が更新されます。
動作を確認します。
[プログラム]タブから[ジョグ]を選択しロボットのエンド エフェクターを動作させます。
メインルーチンに各軸補間ステートメント及び直線補間ステートメントを追加します。
ロボットプログラムを実行すると設定したポイントからポイントへ動作することが確認できます。
ロボットにはジョイントの速度とリミットのデフォルト値があらかじめ設定されており、ロボットが早すぎたり遅すぎる場合や可動領域を超える場合があります。
各ジョイントのプロパティは[コンポーネントグラフ]のリンクを選択し[リンクプロパティ]から最小、最大リミット、最大速度、最大加減速などの設定を変更することができます。
[モデリング]タブから全てのコンポーネントのプロパティとビヘイビアにアクセスできます。
例えばルートノードを選択した場合コンポーネント名とマテリアルを変更できます。
最大デカルト速度加減速度などのプロパティは、コンポーネントグラフのビヘイビアからロボットコントローラーを選択し、コントローラープロパティで変更することができます。
ロボットの原点を移動する場合は、ロボットのコンポーネントを選択し、原点グループからスナップもしくは移動をクリックします。
ロボットの原点を変更します。
変更後、原点を移動パネルから適用をクリックし、変更した位置を保存します。
同様にルートの中にあるルートフレームフィーチャも設定した原点位置に移動します。
ロボットのワールドフレームを移動する場合は、[プログラム]タブから[ツール]グループの[ロボットワールドフレームを移動]を選択します。
ロボットワールドフレームパネルの座標を親に設定し座標を0にします。
回転ジョイントを含むロボットのモデル化について説明します。
L3Zトランスの先端にはスイベル機構があり3つの回転ジョイントで構成されています。
回転ジョイントのリンクをコンポーネントグラフに追加します。
ロボットのコンポーネントを選択した状態で構造グループのリンクをクリエイトを使用しリンクを3つ追加します。
[リンクプロパティ]から名称をL4_Rot1、L5_Rot2、L6_Ro3に変更します。
リンクの階層位置をドラッグアンドドロップで変更します。
L3_Z_Trans、L4_Rot1、L5_Rot2、L6_Ro3、mountplateの順に配下になるように変更します。
生成したリンクにジオメトリフィーチャを移動します。
3Dワールドでジオメトリの位置を保持するためシフトキーを押しながらドラッグアンドドロップで移動します。
L4_Rot1にZ軸方向に回転動作する部品を移動します。
L5_Rot2にY軸方向に回転動作する部品を移動します。
L6_Rot3に先端の部品を移動します。
リンク原点が回転軸となるためリンク原点を適正な位置に移動します。
[移動モード]グループを[選択済み]に設定し[ツール]グループから[スナップ]を選択します。
L4_Rot1とL5_Rot2は円柱の中心にリンク原点を移動します。
L6_Rot3は六角柱の中心にリンク原点を移動します。
リンクプロパティ設定します。
L4_Rot1とL6_Rot3のリンクプロパティはジョイントタイプを「回転」、軸を+Z、コントローラーをRobotControllerに設定します。
L5_Rot2のリンクプロパティは、ジョイントタイプを「回転」、[軸]を「+Y」、コントローラーをRobotControllerに設定します。
mountplateのリンク原点とフランジフレームフィーチャがロボットのエンドエフェクターの位置にあることを確認します。
[コンポーネントグラフ]のビヘイビアからKinematicsIterativeJacobianをダブルクリックしスクリプトを開きます。
変更を適用するためにスクリプトをコンパイルします。
スクリプトの任意の場所に空の行を追加しコンパイルをクリックします。
スクリプトを閉じます。
[プログラム]タブから[ジョグ]を選択しロボットのエンドエフェクターを動作させます。
メインルーチンに各軸補間ステートメントを追加します。
ロボットプログラムを実行すると設定したポイントからポイントへ動作することが確認できます。
eカタログのモデルを参照し直角座標ロボットをモデル化する方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

正規分布を使用して疑似乱数を作ってみよう

分布プロパティを作成し、正規分布を使用して疑似乱数を作る方法
パイソンスクリプト（Python）を使用してシード値を変更する方法
https://youtu.be/1eIRK3tjr0M

正規分布を使用して、疑似乱数を作る方法を説明します。
指定したルールで疑似乱数を出力できるようになります。
[モデリング]タブを開きます。
[コンポーネント]-[新規]を選択し、コンポーネントを作成します。
[ジオメトリ]-[フィーチャ]-[ブロック]を選択し、ブロックを作成します。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
パイソンスクリプトダイアログが開くため、デフォルトで記述されているソースコードを1行目以外削除します。
comp = getComponent()と記述し、Pythonスクリプトを設定しているコンポーネントを取得します。
prop = comp.getProperty()と記述し、コンポーネント内に指定したプロパティが存在するか確認します。
Test_Distributionというプロパティ名を探します。
if not prop: prop = comp.createProperty()と記述し、プロパティが存在しない場合、プロパティを作成します。
分布タイプのプロパティを作成するので、VC_DISTRIBUTIONと記述します。
プロパティの名前は"Test_Distribution"とします。
「prop.Distribution = 」と記述し、分布の計算に使用する式を定義します。
正規分布は、統計学における確率の考え方の一種です。本動画では説明しません。
nomalと記述し、分布の種類を正規分布とします。
nomalは、ダブルコーテーションで囲みます。
1番目の引数は平均値を指定します。平均値を10.0とします。
2番目の引数は標準偏差を指定します。標準偏差を2.0とします。
標準偏差とは、乱数の値のばらつきです。
平均値10.0、標準偏差2.0の正規分布の値を5回確認します。
for i in range(5)と記述し、変数のiを5回ループします。
print prop.Valueと記述し、正規分布の数値を表示します。
コンパイルボタンをクリックします。
[コンポーネントグラフ]ウィンドウのプロパティの表示がオンになっていることを確認します。
プロパティを展開すると、Test_Distributionが追加されていることがわかります。
Test_Distributionには、正規分布の値が表示されています。
[出力]ウィンドウを確認すると、正規分布の値が5回表示されていることがわかります。
分布のプロパティの数値を5回チェックし、表示しているため、毎回異なる値を表示します。
再度、正規分布の値を表示します。
PythonScriptのウィンドウで、printとダッシュを記述し、5回値を表示させた後、区切り線が入るようにします。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、区切り線と異なる値が5回表示されていることがわかります。
シミュレーションを実行し、[出力]ウィンドウに値を表示します。
PythonScriptのウィンドウで、def OnRun()と記述し、シミュレーション開始時にOnRun内のソースコードがトリガーされるよう定義します。
print以下を選択し、tabキーを押し、OnRun内にソースコードを移動します。
コンパイルボタンをクリックします。
シミュレーションを実行し、リセットします。
正規分布の値が5回表示されます。
再度、シミュレーションを実行し、リセットします。
前回と同じ値が表示されていることがわかります。
シミュレーション実行時に正規分布の値を表示すると、シード値が定義されるため、値は変化しません。
シード値とは、値を取得する際に、最初に設定される値です。
シード値が定義されると、最初に設定された値を同様に表示することができます。
3Dワールドのレイアウトには、64 個のストリームを含むレイアウ ト項目があります。
レイアウト項目は、寸法や注釈など、コンポーネント以外のオブジェクトの見た目に関する項目のことです。
ストリームとは、先頭から順番に処理する連続したデータのことを言います。
各ストリームは、それぞれ独自のシード値を持つことができます。
つまり、ストリームごとに異なる値を生成することができます。
prop.RandomStream =と記述し、各ストリーム固有の数値を参照します。
0～63までのインデックスを使用して、ストリームを参照することができます。
今回は、10を使用し、コンパイルボタンをクリックします。
シミュレーションを実行し、リセットします。
再度実行し、リセットします。
[出力]ウィンドウを確認すると、同じ値が繰り返し表示されていることがわかります。
レイアウト内の64個のストリームは、デフォルトでは同じシード値を持っているため、シミュレーションを実行すると、同じ値が表示されます。
64個のストリームが、同じシード値を持っていることを確認します。
app = getApplicationと記述し、アプリケーション情報を取得します。
stream = app.findLayoutItemと記述し、アプリケーション内のレイアウト項目を探します。
レイアウト項目名は、RandomSeedsとします。
RandomSeeds項目のプロパティを確認します。
for p in streams.Properties:print p.Name, p.Valueと記述し、プロパティ名と値を表示します。
[出力]ウィンドウの表示エリアを右クリックし、clearを選択し、表示履歴を削除します。
コンパイルボタンをクリックします。
[出力]ウィンドウにRandomSeedとシード値が表示されます。
RandomSeed0はシード値が1であり、RandomSeed63まで同じシード値であることがわかります。
異なる値を取得したい場合は、シード値を変更する必要があります。
for p in streams.Properties:以下の2行をコメントアウトし、コードを無効化します。
コメントアウトするには、アポストロフィーをコメントアウトしたいソースコードの最初と最後に3つずつ付けます。
RandomSeedは10を使用しているため、streams.RandomSeed10と記述し、RandomSeed10のシード値を変更します。
シード値は400にします。
コンパイルボタンをクリックします。
[出力]ウィンドウの表示履歴を削除します。
シミュレーションを実行し、リセットします。
再度実行し、リセットします。
[出力]ウィンドウを確認すると、先ほどとは異なる値が繰り返し表示されていることがわかります。
シード値を変更すると、異なる値のセットが取得できます。
このように、疑似乱数を使用する場合、値を制御することができます。
仮に、レイアウトを変更し、他者と共有した場合でも、共有先でシミュレーションを実行し、同じ値を得ることができます。
prop.RandomStreamをコメントアウトし、異なる方法でRandomSeedの番号を指定します。
1行ずつコメントアウトする場合は、＃を使用します。
prop.Distributionのnormalの最初の引数に50と記述し、RandomSeedを50に指定します。
コンパイルボタンをクリックします。
シミュレーションを実行し、リセットします。
再度実行し、リセットします。
[出力]ウィンドウを確認すると、先ほどとは異なる値が繰り返し表示されていることがわかります。
RandomSeedを10から50に変更したため、異なる値のセットが取得できます。
レイアウト外のストリームを指定します。
レイアウト内のストリームは0～63の64個使用できるため、normalに63より大きい70を指定し、レイアウト外のストリームにします。
コンパイルボタンをクリックします。
シミュレーションを実行し、リセットします。
再度実行し、リセットします。
[出力]ウィンドウを確認すると、異なる値が繰り返し表示されていることがわかります。
同じ数値のセットを取得したい場合は、64個のストリームを使用し、必要なシード値を指定します。
今回使用したPython APIは、ヘルプから確認することができます。
[ヘルプ]タブを開きます。
[パイソンAPI]をクリックすると、ヘルプダイアログが表示されます。
[目次]-[Japanese]-[vcComponent]を開きます。
[メソッド]をクリックすると、createPropertyがあります。
createPropertyは、プロパティを作成します。
getPopertyは、プロパティを取得します。
vcPropertyをクリックすると、Distributionがあります。
正規分布の他に、対数正規分布、一様分布などを定義できます。
RandomStreamは、分布関数で、64個の異なる値のセットを生成することができます。
分布の関数内で、ストリーム番号を使用することもできます。
[vcApplication]を開きます。
LayoutItemsは、全てのレイアウト項目を取得できます。
[メソッド]をクリックすると、[レイアウト項目]にfindLaytouItemがあります。
findLayoutItemは、指定したレイアウト項目を取得できます。
正規分布を使用して、疑似乱数を作る方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

製品に穴をあけよう(1/5)

製品に穴をあける加工機の機構を設定する方法
https://youtu.be/sBe58YPf2Sc
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_187_p1.zip

製品に穴をあける方法について説明します。
本動画では、穴をあける加工機の機構を設定します。
CADファイルをインポートします。
[ホーム]タブ、または[モデリング]タブを開きます。
[インポート]グループの[ジオメトリ]を選択することで、CADファイルをインポートできます。
[HoleSaw.3ds]を選択し、[開く]をクリックします。
[モデルをインポート]ウィンドウでは、インポート時の詳細を設定できます。
ジオメトリの階層構造をシンプルな状態にするため、[フィーチャツリー]で[最適化]を選択します。
ジオメトリの上面と底面を整列させる軸を設定するため、[上軸]で[-X]を選択します。
[インポート]をクリックします。
加工機と、製品のCADファイルをインポートできたことがわかります。
可動部を設定するため、[モデリング]タブを開きます。
青いブロックの下にある黒い円柱を選択します。
右クリック、[抽出]-[抽出リンク]を選択することで、ノードと呼ばれるかたまりとして抽出できます。
[コンポーネントグラフ]ウィンドウに、「Link_1」が追加されたことがわかります。
[リンクプロパティ]ウィンドウで、可動部に動作の詳細を設定します。
[JointType]で、直進を選択することで、動作の種類を直線運動に設定できます。
[軸]で、-Zを選択することで、Z軸を基準とし、マイナス方向に動作させます。
[Controller]をクリックし、「新規サーボコントローラ」を選択します。
[コンポーネントグラフ]ウィンドウに、「サーボコントローラ」が追加されたことがわかります。
Geminiのサーボコントローラは、一般的なサーボコントローラとは異なり、可動部を制御する仮想のコントローラを意味します。
[リンクプロパティ]ウィンドウの[初期値]は、ノードの初期位置、[J1]は、ノードの現在位置を表示しています。
現在、[初期値]と[J1]は0です。
[最小リミット]と[最大リミット]は、ノードが動作できる範囲の最小値と最大値を定義できます。
動作できる範囲を設定するため、距離を測定します。
[ツール]グループの[測定]を選択することで、2点間の距離、または角度を測定できます。
緑色の歯の先端と、赤い板の上面を選択します。
Z軸方向の距離が、450mmであることがわかります。
再度、[測定]を選択し、測定モードを終了します。
[リンクプロパティ]ウィンドウで、[最小リミット]を0、[最大リミット]を450に変更します。
[最大加速]と[最大減速]は、現在の速度から目標速度に達するまでの加速と減速の最大値を定義できます。
[最大加速]を0、[最大減速]を0に変更します。
[マニピュレーション]グループの[インタラクティブ]を選択することで、可動部の動作を確認できます。
3Dワールドツールバーの[レンダリングモード]の[ワイヤーフレーム]を選択することで、形状や構造を視覚的に確認できます。
3Dワールドで、「Link_1」をドラッグします。
「Link_1」が、[最小リミット]と[最大リミット]の範囲外に動作すると、[リンクプロパティ]ウィンドウの[J1]にエラーが発生します。
範囲外に動作しない設定にする場合、[プログラム]タブをクリックし、[リミット]グループの[リミットで停止]にチェックを付けます。
[モデリング]タブを開きます。
3Dワールドで、「Link_1」をドラッグします。
「Link_1」は、範囲外に動作しません。
シミュレーションのリセットボタンを選択することで、可動部が初期位置に戻ります。
3Dワールドツールバの[レンダリングモード]の[マテリアルシェード]を選択します。
緑色の歯と、黄色のドリルを、黒い円柱の動作に追従させます。
緑色の歯と、黄色のドリルには、後程、黒い円柱とは別の動作を設定するため、別のノードに抽出します。
緑色の歯と、黄色のドリルを選択します。
複数のジオメトリを選択する場合、[マニピュレーション]グループの[選択]、またはコントロールキーを押した状態で、ドラッグすることで、範囲選択できます。
コントロールキーを押した状態で、ジオメトリを1つずつ選択していくことでも、複数のジオメトリを選択できます。
右クリック、[抽出]-[抽出リンク]を選択します。
[コンポーネントグラフ]ウィンドウに、「Link_2」が追加されたことがわかります。
現在の状態では、「Link_2」は、「Link_1」に追従しません。
「Link_2」を、「Link_1」にドラッグ＆ドロップし、階層構造を設定します。
「Link_1」が親、「Link_2」が子です。
3Dワールドで、「Link_1」をドラッグします。
「Link_1」に追従し、「Link_2」が上下に移動することがわかります。
シミュレーションのリセットボタンを選択します。
「Link_2」に回転動作を設定します。
回転動作を設定する場合、回転の中心軸を定義する必要があります。
回転の中心軸は、ノードの原点です。
[マニピュレーション]グループの[移動]を選択することで、選択したものの原点を表示できます。
「Link_2」の原点を移動させます。
「Link_2」を選択した状態で、3Dワールドの矢印をドラッグします。
「Link_2」のジオメトリごと、移動していることがわかります。
[リンクプロパティ]ウィンドウの[座標]を、すべて0に戻します。
ジオメトリは移動させず、「Link_2」の原点のみ、移動させるため、[移動モード]を[選択済み]に変更します。
[選択済み]の場合、選択したノード、またはフィーチャのみ、移動させることができます。
[ヒエラルキー]の場合、選択したノード等と、その子階層のノード等を移動させることができます。
「Link_2」の原点を、ドリルの先端に移動させます。
[ツール]グループの[スナップ]を選択します。
[スナップ]は、選択しているものを、3Dワールドの選択した位置に移動できる機能です。
ドリルの先端を選択します。
原点の角度は変更しないため、[リンクプロパティ]ウィンドウの[座標]で、[Rx]、[Ry]、[Rz]を0に戻します。
[移動モード]を[ヒエラルキー]に変更します。
[リンクプロパティ]ウィンドウで、可動部に動作の詳細を設定します。
[JointType]で、「回転」を選択することで、動作の種類を回転運動に設定できます。
[軸]は、「+Z」を選択することで、原点のZ軸を中心に動作します。
プラスとマイナスの違いは、回転する方向です。
[Controller]をクリックし、「新規サーボコントローラ」を選択します。
[コンポーネントグラフ]ウィンドウに、「サーボコントローラ_2」が追加されたことがわかります。
[最小リミット]と[最大リミット]で、ノードが動作できる範囲の最小値と最大値を定義します。
[最小リミット]と[最大リミット]に数値を入力しないことで、最小値と最大値を定義しないこともできます。
[最小リミット]に「0」と入力し、[最大リミット]の数値を削除します。
[最大加速]は回転を開始する時の加速、[最大減速]は回転を終了する時の減速の設定です。
今回、10度ずつ、連続で回転させます。
10度回転する度に加速と減速を行うと、一時停止してから再度回転を始めるように見えます。
一時停止せず連続で回転するように見せるため、[最大加速]は「0」、[最大減速]は「0」に変更します。
[マニピュレーション]グループの[インタラクティブ]を選択します。
3Dワールドで、「Link_2」をドラッグします。
「Link_2」が、ドリルを中心に回転することがわかります。
シミュレーションのリセットボタンを選択します。
加工機の機構を設定する方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

製品に穴をあけよう(2/5)

シグナルで加工機の可動部を制御する方法
https://youtu.be/Ye3Jr8x5dZU
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_187_p2.zip

製品に穴をあける方法について説明します。
本動画では、シグナルで可動部を制御する方法について説明します。
サーボをパイソンスクリプトで制御する場合は「サーボをPythonで制御しよう(1/2)」、プロパティやシグナルの値の変化時にイベントが発生した場合は「プロパティやシグナルの変化時にPythonを実行しよう」も参照してください。
動画「製品に穴をあけよう(1/5)」の続きから設定します。
付属ファイル「HoleSaw_after1.vcmx」を開きます。
加工機が動作するタイミングを指示するため、シグナルを追加します。
[モデリング]タブを開きます。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[ブール型]を選択します。
ブール型シグナルとは、ON/OFFの値を送受信できるシグナルです。
[プロパティ]ウィンドウの[名前]を「StartSignal」に変更します。
StartがONの時、「Link_1」を下降させ、StartがOFFの時、「Link_1」を上昇させるため、PythonScriptを追加します。
[コンポーネントグラフ]ウィンドウで、[HoleSaw]を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
エディタが自動的に開くため、デフォルトで記述されているソースコードを1行目以外削除します。
パイソンスクリプトを含むコンポーネントの情報を取得するため、「comp = getComponent()」と記述します。
「servo = comp.findBehaviour("")」と記述することで、コンポーネントのビヘイビアを参照できます。
括弧内にサーボコントローラと記述し、名前が一致するビヘイビアを参照します。
同様に、StartSignalを参照します。
変数名は、startです。
シミュレーション再生中、処理を実行するため、def OnRun():と記述します。
「target = 0」と記述し、変数targetの初期値を0に設定します。
シミュレーション再生中、条件を満たしている場合、繰り返し処理を実行するため、ループ処理を追加します。
「while True:」と記述することで、以下の処理を、シミュレーションを終了するまで、繰り返し実行できます。
while Trueのみでは、一瞬の内に、膨大な回数、処理を実行するため、フリーズします。
処理回数を削減するため、StartSignalの値が変化するまで、待機する処理を追加します。
「delay(0.01)」と記述することで、指定した時間が経過するまで待機させます。
「if start.Value == True and target < 450:」と記述することで、StartSignalがONの場合、かつ、targetが450未満の場合、次の処理を実行できます。
「target += 10」と記述することで、条件が満たされた場合、targetを10増加させます。
「servo.moveJoint()」と記述することで、サーボコントローラが制御している可動部を動作させることができます。
括弧内に「0,target」と記述します。
括弧内の第一引数は、サーボコントローラが制御する可動部のリスト番号です。
第一引数は0から数え始めるため、0は最初の可動部である「Link_1」を示しています。
第二引数は、動作の目標位置です。
「elif start.Value == False and target > 0:」と記述し、StartSignalがOFFの場合、かつ、targetが0より大きい場合、次の処理を実行します。
「target -= 10」と記述することで、条件が満たされた場合、targetを10減少させます。
「servo.moveJoint(0,target)」と記述し、「Link_1」を初期位置まで動作させます。
PythonScriptエディタ左上の[コンパイル]をクリックします。
PythonScriptにシグナルの値の変化を通知するため、PythonScriptとシグナルを接続します。
[コンポーネントグラフ]ウィンドウで、StartSignalを選択します。
[プロパティ]ウィンドウで、[接続]をクリックすることで、プラスアイコンが表示されます。
プラスアイコンをクリックし、表示される[Add Connections items]ウィンドウで、PythonScriptを選択します。
[Add Connections items]ウィンドウを閉じます。
シミュレーションを再生します。
加工機を選択します。
[接続]グループの[シグナル]を選択することで、3Dワールドと、画面右側にシグナルが表示されます。
StartSignalの右側にある丸をクリックし、ONにします。
「Link_1」が下降していることがわかります。
StartSignalをクリックし、OFFにします。
「Link_1」が上昇していることがわかります。
シミュレーションをリセットします。
StartSignalがONの間、「Link_2」を回転させるため、PythonScriptを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
「PythonScript_2」が追加されたことがわかります。
「PythonScript」の内容をコピーし、「PythonScript_2」に貼り付けます。
「PythonScript_2」で参照する「サーボコントローラ」を、「サーボコントローラ_2」に変更します。
StartSignalがONの間、「Link_2」は回転し続けるため、動作の目標位置を加算していきます。
StartSignalがONの間、targetを10度ずつ加算します。
10行目の「and target < 450」を削除し、「if start.Value == True:」にすることで、StartSignalがONの場合、処理を実行できます。
StartSignalがOFFの場合、動作しないため、elif以下の処理を削除します。
PythonScriptをコンパイルします。
シミュレーションを実行します。
加工機を選択します。
[接続]グループの[シグナル]を選択します。
StartSignalをクリックし、ONにします。
「Link_1」が、移動完了した後も、「Link_2」が回転し続けることがわかります。
StartSignalをクリックし、OFFにします。
StartSignalがOFFになると、「Link_2」は停止します。
シミュレーションをリセットします。
シグナルで可動部を制御する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

製品に穴をあけよう(3/5)

プロパティで、製品の見た目を制御する方法（トランスフォーム、再構築、条件演算子）
（関連動画：製品の合体や型抜きをしてみよう）
https://youtu.be/5qQ1ZIHdcgg
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_187_p3.zip

製品に穴をあける方法について説明します。
本動画では、プロパティで、製品の見た目を制御する方法について説明します。
動画「製品に穴をあけよう(2/5)」の続きから設定します。
付属ファイル「HoleSaw_after2.vcmx」を開きます。
現在、製品と加工機が同じコンポーネントに格納されています。
製品を、別のコンポーネントに抽出します。
[モデリング]タブを開きます。
灰色のブロックを選択します。
[フィーチャプロパティ]ウィンドウで[名前]を「Plate」に変更します。
右クリック、[抽出]-[コンポーネントを抽出]を選択することで、選択したフィーチャをコンポーネントに抽出できます。
同様に、穴が開いた円柱も別のコンポーネントに抽出します。
名前は、Ringです。
製品を生成する時、コンポーネントの原点を基準に生成する位置を決定します。
製品の原点を、製品の中心に移動させます。
Plateをダブルクリックすることで、コンポーネントを選択できます。
[原点]グループの[移動]を選択します。
[原点]グループの機能を使用することで、選択したコンポーネント等の原点を移動させることができます。
[原点を移動]ウィンドウの[座標]を変更します。
Xは-2000、Yは-1000、Z、Rx、Ry、Rzは0です。
[適用]を選択します。
同様に、Ringの原点を移動させます。
Ringを選択した状態で、[原点]グループの[移動]を選択します。
X、Yは-1000、Z、Rx、Ry、Rzは0です。
[適用]を選択します。
フィーチャ同士の重なっている部分を型抜きすることで、穴を表現します。
Plateを選択します。
[ジオメトリ]グループの[フィーチャ]を展開し、[プリミティブジオメトリ]から[円柱]を選択します。
円柱の大きさを変更します。
[フィーチャプロパティ]ウィンドウの[半径]に200、[セクション]に36と入力します。
[セクション]では、円柱の外周を構成する面の数を定義します。
数値が大きいほど、滑らかな円柱になります。
Plateと円柱の重なっている部分を型抜きします。
[ジオメトリ]グループの[フィーチャ]を展開し、[その他]から[ブール型]を選択します。
ブール型フィーチャについての詳細は、動画「製品の合体や型抜きをしてみよう」を参照してください。
Plateから、円柱を型抜きするため、上からPlate、円柱の順になるように、Booleanにドラッグします。
Booleanの[フィーチャプロパティ]ウィンドウで、[演算処理]を引き算に変更します。
Plateから、円柱の形で、型抜きされたことがわかります。
穴の深さを変更するため、円柱を移動させます。
[ジオメトリ]グループの[フィーチャ]を展開し、[トランスフォーム]を選択します。
トランスフォームフィーチャは、数式を使用し、階層構造の子に当たるフィーチャを移動、または変形できます。
円柱を移動させるため、[コンポーネントグラフ]ウィンドウ下段で、トランスフォームをBoolean、円柱をトランスフォームにドラッグします。
[フィーチャプロパティ]ウィンドウの[数式]にフィーチャの座標を変更する関数を入力します。
Geminiで使用可能な関数は、[ヘルプ]タブ-[ヘルプ]-[式]-[関数]で確認できます。
フィーチャの座標を変更する場合、関数Tx、Ty、Tz、Posを使用します。
フィーチャのX、Y、Z軸方向の座標を、指定した距離、移動させた座標に変更できます。
[フィーチャプロパティ]ウィンドウの[数式]に、Tz(20)と入力します。
円柱が+Z軸方向に、20mm移動したことで、厚さ100mmのPlateに、深さ80mmの穴があいたことがわかります。
穴の深さを制御するため、プロパティを追加します。
[プロパティ]グループの[プロパティ]を展開し、[ベーシック]から[実数]を選択します。
[プロパティ]ウィンドウの[名前]を、Deepに変更します。
プロパティの値を変更した時、フィーチャの見た目を変化させる場合、[再構築]にチェックを付けます。
[値]に、20と入力します。
Deepの値を穴の深さとして使用するため、[コンポーネントグラフ]ウィンドウ下段のトランスフォームを選択します。
[フィーチャプロパティ]ウィンドウの[数式]を、Tz(100-Deep)に変更します。
Deepの値が穴の深さとして、適用されたことがわかります。
加工機の歯を回転させた時、Ringの形に切り出します。
Ringのフィーチャを選択します。
右クリック、[コピー]を選択します。
Plateを選択し、[コンポーネントグラフ]ウィンドウ下段の[Root]を選択します。
右クリック、[貼り付け]を選択します。
Deepを選択し、[プロパティ]ウィンドウの[値]を100に変更します。
Ringの形に、切り出した状態を、表現できたことがわかります。
穴の深さが100mmに到達した時、Ringを別のコンポーネントとして生成するため、Plateと同じコンポーネント内のRingは見た目を消します。
[コンポーネントグラフ]ウィンドウ下段の[Root]を選択します。
[ジオメトリ]グループの[フィーチャ]を展開し、[トランスフォーム]を選択します。
Ringをドラッグし、トランスフォーム_1の子階層に移動します。
トランスフォーム_1を選択します。
[フィーチャプロパティ]ウィンドウの[数式]に、条件演算子を使用した数式を入力します。
条件演算子の使用方法は、[ヘルプ]タブ-[ヘルプ]-[式]-[グループ化演算子]で確認できます。
条件、クエスチョンマーク、条件を満たしている場合の動作、コロン、条件を満たしていない場合の動作と入力します。
数式は、Deep>=100?Sx(0).Sy(0).Sz(0):Tx(0)です。
Deepが100以上の場合、RingのXYZ軸方向の大きさの倍率を0にします。
Deepが100未満の場合、Ringに対して何もしません。
Deepが100の時、Ringが削除されたことがわかります。
Deepを選択し、値を50に変更します。
Ringが出現したことがわかります。
プロパティで、製品の見た目を制御する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

製品に穴をあけよう(4/5)

製品を生成し、指定した経路を移動させる方法（コンポーネントクリエイター、コンポーネントコンテナ、ワンウェイパス）
https://youtu.be/mpzcuh8VDlY
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_187_p4.zip

製品に穴をあける方法について説明します。
本動画では、製品を生成し、指定した経路を移動させる方法について説明します。
動画「製品に穴をあけよう(3/5)」の続きから設定します。
付属ファイル「HoleSaw_after3.vcmx」を開きます。
MELSOFT Geminiでオリジナルの製品を生成する場合、外部ファイルを読込み、製品として設定する必要があります。
Plateを選択し、[モデリング]タブを開きます。
Plateに穴が開いていない状態にするため、[コンポーネントプロパティ]ウィンドウで、Deepを0に変更します。
製品を外部ファイルに保存します。
[コンポーネント]グループの[名前をつけて保存]を選択することで、選択しているコンポーネントを外部ファイルに保存できます。
[ファイル]タブで、レイアウトとして保存した外部ファイルは、製品として設定することはできません。
[コンポーネントを名前をつけて保存]ウィンドウの[名前をつけて保存]を選択します。
[名前をつけて保存]ウィンドウで、任意の場所に保存します。
同様に、Ringを外部ファイルに保存します。
製品を生成するため、加工機を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[マテリアルフロー]から[コンポーネントクリエイター]を選択します。
コンポーネントクリエイターは、シミュレーション中に新しいコンポーネントを生成できます。
[プロパティ]ウィンドウの[パーツ]で、生成するコンポーネントの元となる外部ファイルを設定できます。
[...]を選択します。
[開く]ウィンドウで、[Plate.vcmx]、[開く]を選択します。
同様に、コンポーネントクリエイターをもう1つ追加し、[パーツ]に「Ring」を設定します。
現在の状態で、シミュレーションを再生しても、製品は表示されません。
コンポーネントクリエイターで生成された動的コンポーネントは、格納する場所がない場合、削除されます。
製品を格納する場所を追加します。
[動作設定]グループの[ビヘイビア]を展開し、[マテリアルフロー]から[コンポーネントコンテナ]を選択します。
コンポーネントコンテナは、設定したコンポーネントに、別のコンポーネントを格納できます。
装置から装置へ、製品を受け渡す場合や、部品を組み合わせて製品を作成する場合は、装置や部品にコンポーネントコンテナを設定します。
コンポーネントクリエイターで生成された動的コンポーネントを、コンポーネントコンテナに格納します。
[コンポーネントグラフ]ウィンドウのComponentCreator、左側にあるプラスアイコンを選択します。
Output、Inputという名前のコネクターが表示されます。
ComponentContainerも、同様にInputとOutputを所持しています。
コネクター同士を接続することで、コンポーネントの受け渡しが可能になります。
コンポーネントを格納している場所のOutputと、別の場所のInputを接続します。
今回は、ComponentCreatorのOutputと、ComponentContainerのInputを接続します。
ComponentCreatorのOutputを選択します。
[プロパティ]ウィンドウの[接続]で、接続先、[ポート]で、接続先のコネクターを選択できます。
[接続]は、ComponentContainer、[ポート]は、Inputです。
[コンポーネントグラフ]ウィンドウで、ComponentContainerのInputを選択します。
[プロパティ]ウィンドウの、接続先がComponentCreatorのOutputであることを確認します。
接続先の[接続]と[ポート]が未設定の場合、自動的に設定されます。
シミュレーションを再生すると、Plateは表示されますが、加工機の原点に表示されます。
Plateを表示する位置を設定します。
[ジオメトリ]グループの[フィーチャ]を展開し、[その他]から[フレーム]を選択します。
フレームとは、3Dワールド上で、位置と方向を定義する基準点です。
加工機の原点にフレームが追加されます。
3Dワールドに、フレームが表示されない場合、3Dワールドツールバーの[フレームタイプ]を展開し、フレームにチェックを付けます。
[フレームタイプ]アイコンが透明な場合、機能は無効となっているため、アイコンを選択し、有効にする必要があります。
3Dワールドに、フレームが表示されたことがわかります。
フレームを移動させます。
[フィーチャプロパティ]ウィンドウの[座標]を変更します。
Xは500、Yは-500、Zは1100です。
コンポーネントコンテナで、フレームを設定し、Plateを表示する位置を定義します。
[コンポーネントグラフ]ウィンドウで、ComponentContainerを選択します。
[プロパティ]ウィンドウの[位置]で、コンポーネントを格納する位置を指定できます。
[位置]で、フレームを選択します。
シミュレーションを再生すると、フレームの位置にPlateが表示されます。
フレームと、コンポーネントのXYZ軸は同じ方向を向いています。
Ringの場合、Plateから切り出した後、地面に落下させます。
指定した経路に沿ってRingを移動させることで、地面への落下を表現できます。
経路の開始位置には、Plateの生成位置を使用します。
経路の終了位置を追加します。
[ジオメトリ]グループの[フィーチャ]を展開し、[その他]から[フレーム]を選択します。
フレーム_1を、フレームの真下に移動します。
[ツール]グループの[スナップ]を使用することで、選択したものを、3Dワールドの選択した位置に移動できます。
[スナップ]ウィンドウの[スナップタイプ]で[フレーム]を選択します。
3Dワールドのフレームを選択します。
[フィーチャプロパティ]ウィンドウの[座標]Zを100に変更します。
指定した経路に沿って、コンポーネントを移動させる設定を追加します。
[動作設定]グループの[ビヘイビア]を展開し、[マテリアルフロー]から[ワンウェイパス]を選択します。
ワンウェイパスは、指定した経路に沿ってコンポーネントを前進させることができます。
前進と後退の2方向に移動させる場合、ツーウェイパスを使用します。
[プロパティ]ウィンドウの[速度]で、コンポーネントが経路を移動する速度を設定します。
[速度]を2000に変更します。
ワンウェイパス内にあるコンポーネント同士を、隣接させる場合、[スペース使用]にチェックをつけます。
隣接させず、経路の終了位置で重なるようにする場合、[スペース使用]のチェックを外します。
今回は、チェックをつけます。
[パス]で、経路を設定できます。
[パス]を選択し、表示されるプラスアイコンを選択します。
[Add Path items]ウィンドウで、フレーム、フレーム_1の順に選択します。
[Add Path items]ウィンドウを閉じます。
ComponentCreator_2のOutputと、OneWayPathのInputを接続します。
[コンポーネントグラフ]ウィンドウで、OneWayPathの左側にあるプラスアイコン、Inputを選択します。
[プロパティ]ウィンドウの[接続]は、ComponentCreator_2、[ポート]は、Outputです。
[コンポーネントグラフ]ウィンドウで、ComponentCreator_2のOutputを選択し、接続先がOneWayPathのInputであることを確認します。
シミュレーションを再生すると、Ringが指定した経路を移動していることがわかります。
Ringは移動完了した時、格納する場所がないため、削除されます。
Ringが、地面に積み上がるようにするため、コンポーネントコンテナを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[マテリアルフロー]から[コンポーネントコンテナ]を選択します。
[プロパティ]ウィンドウの[位置]で、フレーム_1を選択します。
[キャパシティ]では、コンポーネントコンテナが格納可能なコンポーネントの最大個数を設定できます。
[キャパシティ]を1に変更することで、1つのコンポーネント以外、ワンウェイパス内にとどまり、コンポーネント同士を隣接させることができます。
OneWayPathのOutputと、ComponentContainer_2のInputを接続します。
[コンポーネントグラフ]ウィンドウで、OneWayPathのOutputを選択します。
[プロパティ]ウィンドウの[接続]は、ComponentContainer_2、[ポート]は、Inputです。
[コンポーネントグラフ]ウィンドウで、ComponentContainer_2のInputを選択し、接続先がOneWayPathのOutputであることを確認します。
シミュレーションを再生すると、Ringが積み上げられていることがわかります。
シミュレーションを再生したまま放置すると、Ringが生成され続け、コンピュータが重くなる可能性があるため、注意が必要です。
OneWayPathの終了位置と、ComponentContainer_2の位置が同じであるため、1つ目と2つ目のRingは、重なっています。
OneWayPathの終了位置と、ComponentContainer_2の位置の間に、Ring1つ分の距離をあけることで、改善できます。
[コンポーネントグラフ]ウィンドウ下段のフレーム_1を選択し、コピーします。
[Root]を選択し、貼り付けます。
[フィーチャプロパティ]ウィンドウの[名前]をフレーム_2、[座標]Zを200に変更します。
[コンポーネントグラフ]ウィンドウで、OneWayPathを選択します。
[プロパティ]ウィンドウの[パス]をフレーム、フレーム_2に変更します。
シミュレーションを再生すると、Ring同士が重ならず、積み上げられていることがわかります。
製品を生成し、指定した経路を移動させる方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

製品に穴をあけよう(5/5)

可動部の現在値に合わせて、製品の穴の深さを制御する方法
https://youtu.be/8QW5_FXBoXU
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_187_p5.zip

製品に穴をあける方法について説明します。
本動画では、可動部の現在値に合わせて、製品の穴の深さを制御します。
動画「製品に穴をあけよう(4/5)」の続きから設定します。
付属ファイル「HoleSaw_after4.vcmx」を開きます。
製品を生成するタイミングを、シグナルで制御します。
加工機を選択し、[モデリング]タブを開きます。
[コンポーネントグラフ]ウィンドウで、ComponentCreatorを選択します。
[プロパティ]ウィンドウの[インターバル]は、コンポーネントクリエイターがコンポーネントを生成する間隔、[リミット]は、コンポーネントを生成できる最大個数です。
シグナルで制御するため、[インターバル]と[リミット]を0に変更します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[ブール型]を選択します。
[プロパティ]ウィンドウで[名前]を「PlateSignal」に変更します。
コンポーネントクリエイターとシグナルを接続することで、シグナルの値の変化を検知し、コンポーネントを生成できます。
[接続]を選択し、表示されたプラスアイコンを選択します。
[Add Connections items]ウィンドウで、ComponentCreatorを選択します。
[Add Connections items]ウィンドウを閉じます。
シミュレーションを再生し、PlateSignalをONにすることで、Plateを1つ生成します。
Ringは、「Link_1」が下降した時、加工機上にPlateが存在する場合、生成します。
ComponentCreator_2を選択し、[インターバル]と[リミット]を「0」に変更します。
「Link_1」が下降した時、Plateを検出するセンサーを設定します。
センサーの検出位置を設定するため、フレームを追加します。
「Link_1」を選択します。
[ジオメトリ]グループの[フィーチャ]を展開し、[その他]からフレームを選択します。
センサーの検出範囲を、緑色の歯の高さとするため、フレームを移動させます。
[ツール]グループの[スナップ]を選択します。
緑色の歯の上面を選択します。
センサーの検出範囲は、フレームの+Z軸方向に設定されるため、[フィーチャプロパティ]ウィンドウの[座標]Rxを「180」に変更します。
センサーを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[センサー]から[レイキャスト]を選択します。
レイキャストセンサーは、定義したフレームの位置から光線を照射し、光線と交差したコンポーネントを検出できます。
センサーの位置を、フレームを選択して、定義します。
[プロパティ]ウィンドウの[フレーム]で、フレーム_3を選択します。
選択したフレームの+Z軸方向に光線は照射されます。
表示する光線の長さと、製品を検出する範囲を設定します。
[最大範囲]は、センサーと、検出したコンポーネントとの距離を測定できる範囲です。
[シグナル範囲]で、実数型シグナルを定義することで、距離を出力できます。
今回、距離は測定しませんが、3Dワールドに表示される光線の長さを変更するため、[最大範囲]を「100」に変更します。
[検出しきい値]は、コンポーネントを検出できる範囲です。
[検出しきい値]を100に変更します。
3Dワールド上の光線の表示/非表示は、[光線表示]で変更可能です。
センサーが検出した製品の情報を取得する場合、[コンポーネントシグナル]を設定します。
コンポーネントシグナルとは、コンポーネントの情報を、値として送受信できるシグナルです。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[コンポーネント]を選択します。
[コンポーネントグラフ]ウィンドウで、RaycastSensorを選択します。
[プロパティ]ウィンドウの[コンポーネントシグナル]で、ComponentSignalを選択します。
「Link_1」の現在値に合わせて、製品の穴の深さを制御するため、PythonScriptを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
エディタが自動的に開くため、デフォルトで記述されているソースコードを1行目以外削除します。
パイソンスクリプトを含むコンポーネントの情報を取得するため、comp = getComponent()と記述します。
sig = comp.findBehaviour("")と記述することで、コンポーネントのビヘイビアを参照できます。
括弧内にComponentSignalと記述し、名前が一致するビヘイビアを参照します。
同様に、ComponentCreatorとComponentCreator_2を参照します。
変数名は、creatorとcreator_2です。
creator = comp.findBehaviour("ComponentCreator")、creator_2 = comp.findBehaviour("ComponentCreator_2")と記述します。
link = comp.findNode("")と記述することで、コンポーネントのノードを参照できます。
括弧内に「Link_1」と記述し、名前が一致するノードを参照します。
.Dofと記述することで、ノードの動作に関するプロパティを参照できます。
シミュレーション再生中、処理を実行するため、def OnRun():と記述します。
while True:と記述し、以下のプログラムをループさせます。
プログラムを処理する時、時間に猶予を与えるため、delay(0.1)と記述し、遅延を発生させます。
センサーが製品を検出した時、処理を実行します。
センサーが製品を検出した時、ComponentSignalの値に、コンポーネントの情報が格納されます。
ComponentSignalの値が、空ではない場合、処理を実行するため、if sig.Value != None:と記述します。
prod = sig.Valueと記述し、製品を定義します。
info = prod.getProperty("")と記述することで、製品のプロパティを参照できます。
括弧内に、Deepと記述することで、名前が一致するプロパティを取得します。
info.Value =link.VALUEと記述することで、Deepに「Link_1」の現在値を代入できます。
link.VALUEには、「Link_1」の初期位置から製品の上面に到達する位置までの距離も含まれています。
「-350」と追記し、「Link_1」の初期位置から製品の上面に到達する位置までの距離を引きます。
フィーチャやジオメトリを操作した場合、見た目を更新するため、再構築する必要があります。
prod.rebuild()と記述することで、再構築できます。
穴が貫通した時、Ringを生成します。
「Link_1」が下降端に到達した時、処理を実行するため、if link.VALUE == 450:と記述します。
creator_2.create()と記述することで、ComponentCreator_2から新しいRingのコンポーネントを生成できます。
def OnSignal(signal):と記述することで、接続されたシグナルの値が変化したときに実行します。
if signal.Value == True:と記述することで、Signalの値がTrueであるかどうか確認します。
creator.create()と記述することで、ComponentCreatorから新しいPlateのコンポーネントを生成できます。
PythonScriptをコンパイルします。
加工機を選択します。
[コンポーネントグラフ]ウィンドウのPlateSignalを選択します。
[プロパティ]ウィンドウの[接続]を選択し、ComponentCreatorを削除します。
プラスアイコンを選択します。
[Add Connections items]ウィンドウで、PythonScript_3を選択し、PlateSignalとPythonScript_3を接続します。
[Add Connections items]ウィンドウを閉じます。
シミュレーションを再生します。
PlateSignalをONにし、製品を1つ生成します。
StartSignalをONにし、加工機の動作を開始します。
緑色の歯が、製品を貫通する前に、シミュレーションを一時停止します。
[マニピュレーション]グループの[移動]を選択し、製品を移動させます。
加工機の下降に伴い、製品の穴が深くなっていることがわかります。
コントロールキーとZキーを同時に押し、製品を移動する前の状態に戻します。
シミュレーションを再開します。
加工機が下降端に到達した時、Ringが生成されたことがわかります。
StartSignalをOFFにし、加工機を上昇させます。
穴が製品を貫通していることがわかります。
シミュレーションをリセットします。
製品に穴をあける方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

製品に溝を掘ろう(1/3)

加工機と製品のCADファイルをインポートし、溝を掘る加工機の機構を設定する方法
https://youtu.be/og-zFW0lgRY
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_182_p1.zip

製品に溝を掘る方法について説明します。
本動画では、溝を掘る加工機の機構を設定します。
CADファイルをインポートします。
[ホーム]タブ、または[モデリング]タブを開きます。
[インポート]グループの[ジオメトリ]を選択することで、CADファイルをインポートできます。
[DiggingTrench.3ds]を選択し、[開く]をクリックします。
[モデルをインポート]ウィンドウでは、インポート時の詳細を設定できます。
ジオメトリの階層構造をシンプルな状態にするため、[フィーチャツリー]で[最適化]を選択します。
ジオメトリの上面と底面を整列させる軸を設定するため、[上軸]で[-X]を選択します。
[インポート]をクリックします。
加工機と、製品のCADファイルをインポートできたことがわかります。
可動部を設定するため、[モデリング]タブを開きます。
黒い円柱を選択します。
右クリック、[抽出]-[抽出リンク]を選択することで、ノードというかたまりとして抽出できます。
[コンポーネントグラフ]ウィンドウに、「Link_1」が追加されたことがわかります。
[リンクプロパティ]ウィンドウで、可動部に動作の詳細を設定します。
[JointType]で、直進を選択することで、動作の種類を直線運動に設定できます。
-X軸方向に動作させます。
[Controller]は、ノードの動作を制御するコントローラを定義できます。
[Controller]をクリックし、新規サーボコントローラを選択します。
[コンポーネントグラフ]ウィンドウに、サーボコントローラが追加されたことがわかります。
Geminiのサーボコントローラは、一般的なサーボコントローラとは異なり、可動部を制御する仮想のコントローラを意味します。
[リンクプロパティ]ウィンドウの[初期値]は、ノードの初期位置、[J1]は、ノードの現在位置を表示しています。
現在、[初期値]と[J1]は0です。
[最小リミット]と[最大リミット]は、ノードが動作できる範囲の最小値と最大値を定義できます。
動作できる範囲を設定するため、距離を測定します。
[ツール]グループの[測定]を選択することで、2点間の距離、または角度を測定できます。
緑のブロックの角を2カ所選択します。
X軸方向の距離が、1400mmであることがわかります。
再度、[測定]を選択し、測定モードを終了します。
[リンクプロパティ]ウィンドウで、[最小リミット]を0、[最大リミット]を1400に変更します。
[マニピュレーション]グループの[インタラクティブ]を選択することで、可動部の動作を確認できます。
3Dワールドで、「Link_1」をドラッグします。
「Link_1」が、[最小リミット]と[最大リミット]の範囲外に動作すると、[リンクプロパティ]ウィンドウの[J1]にエラーが発生します。
範囲外に動作しない設定にする場合、[プログラム]タブをクリックし、[リミット]グループの[リミットで停止]にチェックを付けます。
[モデリング]タブを開きます。
3Dワールドで、「Link_1」をドラッグします。
「Link_1」は、範囲外に動作しません。
シミュレーションのリセットボタンを選択することで、可動部が初期位置に戻ります。
上下に動作する可動部を設定します。
灰色の部品をすべて、Ctrlキーを押しながら選択します。
右クリック、[抽出]-[抽出リンク]を選択します。
[コンポーネントグラフ]ウィンドウに、「Link_2」が追加されたことがわかります。
現在、「Link_1」の動作に「Link_2」は追従しません。
追従させるため、shiftキーを押した状態で、「Link_2」を「Link_1」にドラッグします。
「Link_1」を動作させると、「Link_2」が追従することがわかります。
シミュレーションのリセットボタンを選択します。
[リンクプロパティ]ウィンドウで、可動部に動作の詳細を設定します。
[JointType]は、「直進」、[軸]は、「-Z」です。
[Controller]で、「サーボコントローラ」を選択します。
1つのサーボコントローラで、複数の可動部を制御できます。
可動部は、[Controller]を設定した順に、リストに追加されます。
可動部が動作できる範囲を制限するため、[最小リミット]に0、[最大リミット]に200と入力します。
3Dワールドで、「Link_2」をドラッグします。
「Link_2」が、Z軸方向に動作することがわかります。
リセットボタンをクリックします。
加工機の可動部を設定する方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

製品に溝を掘ろう(2/3)

パイソンスクリプト（Python）を使用して、シグナルで加工機の可動部を制御する方法
https://youtu.be/n1KWRk8IGEE
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_182_p2.zip

製品に溝を掘る方法について説明します。
本動画では、シグナルで可動部を制御する方法について説明します。
動画「製品に溝を掘ろう(1/3)」の続きから設定します。
付属ファイル「DiggingTrench_after1.vcmx」を開きます。
加工機が動作するタイミングを指示するため、シグナルを追加します。
[モデリング]タブを開きます。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[ブール型]を選択します。
ブール型シグナルとは、ON/OFFの値を送受信できるシグナルです。
[プロパティ]ウィンドウの[名前]を「Go」に変更します。
同様に、ブール型シグナルを1つ追加し、名前を「Back」に変更します。
加工機の動作した回数を記録するため、プロパティを追加します。
[プロパティ]グループの[プロパティ]を展開し、[ベーシック]から[整数]を選択します。
[プロパティ]ウィンドウの[名前]を「Count」に変更します。
Countが増加するたびに、「Link_2」の下降位置を下げるため、PythonScriptを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
エディタが自動的に開くため、デフォルトで記述されているソースコードを1行目以外削除します。
パイソンスクリプトを含むコンポーネントの情報を取得するため、「comp = getComponent()」と記述します。
「servo = comp.findBehaviour("")」と記述することで、コンポーネントのビヘイビアを参照できます。
括弧内に「サーボコントローラ」と記述し、名前が一致するビヘイビアを参照します。
同様に、「Go」と、「Back」を参照します。
変数名は、go、backです。
「cnt = comp.getProperty("")」と記述することで、コンポーネントのプロパティを参照できます。
括弧内にCountと記述し、名前が一致するプロパティを参照します。
動作の回数が増加するたびに、「Link_2」の下降位置を下げ、「Link_1」を動作させる関数を作成します。
関数を作成することで、PythonScriptの行数を削減できます。
「def Dig():」と記述し、Digという名前の関数を作成します。
括弧内に、変数名を入力することで、実行場所によって、異なる値を受け取ることができます。
複数の変数を、受け取ることも可能です。
括弧内にvalueと記述します。
「Link_2」が動作できる範囲には、制限があるため、動作可能な回数を設定します。
「if cnt.Value < 20:」と記述し、20回より少ない場合、動作します。
「cnt.Value += 1」と記述し、動作回数に1加算します。
「servo.moveJoint()」と記述することで、サーボコントローラが制御している可動部を動作させることができます。
括弧内に「1,cnt.Value*10」と記述します。
括弧内の第一引数は、サーボコントローラに定義されているリストの1番目を表しています。
リストの番号は、0から始まります。
第二引数は、動作の目標位置です。
「servo.moveJoint(0,value)」と記述することで、実行時に送られてきた目標位置に、「Link_1」を動作させることができます。
シミュレーション再生中、処理を実行するため、「def OnRun():」と記述します。
シミュレーション開始時、動作回数をリセットするため、「cnt.Value = 0」と記述します。
「while True:」と記述し、以下のプログラムをループさせます。
「triggerCondition()」と記述することで、指定した関数がTrueの値を返すまで、待機できます。
シグナルGo、またはBackの値が切り替わるまで待機するため、カッコ内に、関数を記述します。
lambda:と記述することで、名前を持たない関数を1行で記述できます。
getTrigger()==goと記述し、PythonScriptと接続されているシグナルがGoであり、値が切り替わった場合、Trueを返します。
or getTrigger()==backと追記し、Backの値が切り替わった場合もTrueを返します。
if go.Value == True:と記述し、GoがTrueの場合の処理を設定します。
Dig(1400)と記述することで、1400という数値を送信し、関数Digを実行できます。
「Link_1」が、1400の位置まで動作します。
BackがTrueの場合の処理を設定するため、elif back.Value == True:と記述します。
Dig(0)と記述し、0という数値を送信し、関数Digを実行します。
「Link_1」が、初期位置に戻ります。
Pythonスクリプトエディタ左上の[コンパイル]をクリックします。
PythonScriptでgetTriggerを使用するため、PythonScriptとシグナルを接続します。
[コンポーネントグラフ]ウィンドウで、Goを選択します。
[プロパティ]ウィンドウで、[接続]をクリックすることで、プラスアイコンが表示されます。
プラスアイコンをクリックし、表示される[Add Connections items]ウィンドウで、PythonScriptを選択します。
[Add Connections items]ウィンドウを閉じます。
同様に、BackとPythonScriptを接続します。
シミュレーションを実行します。
加工機を選択します。
[接続]グループの[シグナル]を選択することで、3Dワールドと、画面右側にシグナルが表示されます。
Goの右側にある丸をクリックし、ONにします。
「Link_2」が10mm下降し、「Link_1」が動作していることがわかります。
GoをOFFにし、BackをONにします。
「Link_2」が、さらに10mm下降し、「Link_1」が初期位置まで移動します。
シミュレーションをリセットします。
シグナルで可動部を制御する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

製品に溝を掘ろう(3/3)

パイソンスクリプト（Python）を使用して、加工機で製品に溝を掘る方法
（関連動画：製品の合体や型抜きをしてみよう、センサーを作ってみよう）
https://youtu.be/k30VVCzTVPs
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_182_p3.zip

製品に溝を掘る方法について説明します。
動画「製品に溝を掘ろう(2/3)」の続きから設定します。
付属ファイル「DiggingTrench_after2.vcmx」を開きます。
現在、加工機と、製品は同じコンポーネントに所属しています。
製品を、別のコンポーネントに抽出します。
[モデリング]タブを開きます。
茶色のブロックを選択します。
右クリック、[抽出]-[コンポーネントを抽出]を選択することで、選択したフィーチャをコンポーネントに抽出できます。
[コンポーネントプロパティ]ウィンドウで、[名前]をProductに変更します。
フィーチャ同士の重なっている部分を型抜きすることで、溝を表現します。
[ジオメトリ]グループの[フィーチャ]を展開し、[プリミティブジオメトリ]から[円柱]を選択します。
円柱の大きさを変更します。
[フィーチャプロパティ]ウィンドウの[半径]に100、[高さ]に1000と入力します。
円柱を移動させるため、[ツール]グループの[スナップ]を選択します。
[スナップ]は、選択したものを、原点を基準に、次に選択した位置に移動させることができます。
茶色のブロックの辺の中央を選択します。
茶色のブロックと円柱が接するように、位置と角度を変更します。
[フィーチャプロパティ]ウィンドウの[座標]で、Zを1100、Ryを90に変更します。
オレンジ色のブロックを追加します。
[コンポーネントグラフ]ウィンドウ下側の[Root(Product)]をクリックします。
[ジオメトリ]グループの[フィーチャ]を展開し、[プリミティブジオメトリ]から[ブロック]を選択します。
オレンジ色のブロックの大きさを変更します。
[フィーチャプロパティ]ウィンドウの長さに[200]、幅に[200]、高さに[1000]と入力します。
オレンジ色のブロックを選択し、[ツール]グループの[整列]を選択します。
[整列]は、選択した2点の位置や向きを基準に、コンポーネントを移動させることができます。
オレンジ色のブロックの面の中央、円柱の面の中央の順に選択します。
円柱の半分とオレンジ色のブロックの半分が重なるように、位置を変更します。
[フィーチャプロパティ]ウィンドウの[座標]で、Xを0、Zを1300に変更します。
円柱とオレンジ色のブロックが、茶色のブロックと重なっている部分を型抜きします。
[コンポーネントグラフ]ウィンドウ下側の[Root(Product)]をクリックします。
[ジオメトリ]グループの[フィーチャ]を展開し、[その他]から[ブール型]を選択します。
ブール型フィーチャについての詳細は、動画[製品の合体や型抜きをしてみよう]を参照してください。
茶色のブロックから、円柱とオレンジ色のブロックを型抜きするため、上から茶色のブロック、円柱とオレンジ色のブロックの順になるように、Booleanにドラッグします。
[ジオメトリ]グループの[フィーチャ]を展開し、[トランスフォーム]を選択します。
トランスフォームフィーチャは、数式を使用し、階層構造の子に当たるフィーチャを移動、または変形できます。
堀り進める度に、円柱とオレンジ色のブロックを下に移動させるため、[コンポーネントグラフ]ウィンドウ下段で、トランスフォームをBoolean、円柱とオレンジ色のブロックをトランスフォームにドラッグします。
[フィーチャプロパティ]ウィンドウの[数式]にフィーチャの座標を変更する関数を入力します。
Geminiで使用可能な関数は、[ヘルプ]タブ-[ヘルプ]-[式]-[関数]で確認できます。
フィーチャの座標を変更する場合、関数Tx、Ty、Tzを使用します。
フィーチャのX、Y、Z軸方向の位置を、指定した距離で移動できます。
[フィーチャプロパティ]ウィンドウの[数式]に、Tz(-200)と入力します。
円柱をZ軸方向に-200移動させることができます。
Booleanを選択し、[フィーチャプロパティ]ウィンドウで、[演算処理]を引き算に変更します。
茶色のブロックから円柱とオレンジ色のブロックの両方が型抜きされたことがわかります。
円柱とオレンジ色のブロックを移動させず、トランスフォームのみ移動させる場合、3通りの方法があります。
1つ目は、円柱とオレンジ色のブロックを、トランスフォームの子にする前に、トランスフォームを移動させる方法です。
2つ目は、[移動モード]を[選択済み]に変更し、トランスフォームのみ移動させる方法です。
[ヒエラルキー]は、子に影響を与え、[選択済み]は、子に影響を与えません。
3つ目は、[原点]グループの[移動]、または[スナップ]を選択し、トランスフォームの原点を移動させる方法です。
溝の深さを制御するため、プロパティを追加します。
[プロパティ]グループの[プロパティ]を展開し、[ベーシック]から[実数]を選択します。
[プロパティ]ウィンドウの[名前]を、Deepに変更します。
プロパティの値を変更した時、フィーチャの見た目が変化する場合、[再構築]にチェックを付ける必要があります。
[値]に、200と入力します。
Deepの値を円柱のZ軸方向の移動距離として使用するため、[コンポーネントグラフ]ウィンドウ下段のトランスフォームを選択します。
[フィーチャプロパティ]ウィンドウの[数式]を、Tz(-Deep)に変更します。
Deepの値に設定した移動距離が、適用されたことがわかります。
製品の情報であるDeepを取得し、加工機の動作回数に応じてDeepの数値を変更します。
今回は、シミュレーション開始前から製品が配置されていますが、シミュレーション開始後に製品を生成する場合もあります。
シミュレーション開始後に生成した製品の情報を取得する方法は、動画「センサーを作ってみよう」を参照してください。
加工機のPythonScriptを編集します。
加工機を選択し、[コンポーネントグラフ]ウィンドウの[PythonScript]をダブルクリックします。
Pythonスクリプトエディタが開きます。
3Dワールドに配置されている製品を取得するため、Geminiのアプリケーションにアクセスします。
「cnt =」の下にapp = getApplication()と記述します。
prod = app.findComponent("")と記述することで、3Dワールドに配置されているコンポーネントを検索できます。
括弧内に、Productと記述し、名前が一致するコンポーネントを参照します。
製品の情報であるDeepにアクセスするため、info = prod.getProperty("")と記述します。
括弧内に、Deepと記述することで、名前が一致するプロパティを参照できます。
加工機の動作後、溝の深さを増加させるため、関数Digの最後の行に記述します。
info.Value = cnt.Value*20.0と記述し、動作回数の20.0掛けた値を代入します。
*20.0とすることで、計算結果が、自動的に実数型に変換されます。
シミュレーション開始時、Deepの初期値を設定するため、関数OnRunの最初の行に記述します。
初期値を0にするため、info.Value = 0.0と記述します。
PythonScriptをコンパイルします。
シミュレーションを実行します。
加工機を選択します。
[接続]グループの[シグナル]を選択し、シグナルを表示します。
GoをONにします。
加工機が動作完了した時、溝を掘ったことがわかります。
GoをOFFにし、BackをONにします。
加工機が動作完了した時、溝が深くなったことがわかります。
シミュレーションをリセットします。
製品に溝を掘る方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

製品の合体や型抜きをしてみよう

ブール型演算処理を使用して、製品の合体や型抜きをする方法
https://youtu.be/rcroqITPHd8
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_133.zip

製品の合体や型抜きをする方法を説明します。
ブール型演算処理を使用することで、合体や型抜きができます。
円柱を追加します。
eカタログの[タイプ別モデル]-[Basic Shapes]を開きます。
[Cylinder Geo]を追加します。
ブロックを追加します。
[モデリング]タブを開きます。
[ジオメトリ]-[フィーチャ]-[ブロック]を選択します。
[フィーチャプロパティ]ウィンドウの[長さ]、[幅]、[高さ]を200にします。
フィーチャツリーのルートノードを選択します。
[ジオメトリ]-[フィーチャ]-[その他]-[ブール型]を選択します。
フィーチャツリーを確認すると、Booleanが追加されていることがわかります。
ブール型をブロックと円柱に適用させるため、Booleanのグループ内にブロックとCylinderを移動します。
ブロックとCylinderを選択し、Booleanにドラッグ＆ドロップします。
ブロックと円柱が重なった部分を抽出します。
Booleanを選択します。
[フィーチャプロパティ]ウィンドウの[演算処理]で[共通部分]を選択します。
[共通部分]は、オブジェクトが重複する部分のみ抽出します。
3Dワールドを確認すると、ブロックと円柱が重なった部分のみ残っていることがわかります。
ブロックと円柱を合体します。
[フィーチャプロパティ]ウィンドウの[演算処理]で[和集合]を選択します。
[和集合]は、重複するオブジェクトを合体します。
3Dワールドを確認すると、ブロックと円柱が合体していることがわかります。
円柱を使用して、ブロックを型抜きします。
[フィーチャプロパティ]ウィンドウの[演算処理]で[引き算]を選択します。
[引き算]は、フィーチャツリーの上の階層のオブジェクトをベースにして、下の階層のオブジェクトで型抜きします。
3Dワールドを確認すると、円柱の形状に沿って、ブロックが型抜きされたことがわかります。
フィーチャツリーのブロックと円柱の階層を入れ替えます。
ブロックを選択し、Cylinderの下にドラッグ&ドロップします。
3Dワールドを確認すると、ブロックの形状に沿って、円柱が型抜きされたことがわかります。
穴の空いたパレットを作成します。
[ファイル]-[全て消去]を選択します。
[ホーム]タブを開きます。
eカタログの[タイプ別モデル]-[Products and Containers]を開きます。
[Parametric Pallet]をダブルクリックし、原点に追加します。
穴を空けるための円柱を作成します。
[モデリング]タブを開きます。
[ジオメトリ]-[フィーチャ]-[円柱]を選択します。
[フィーチャプロパティ]ウィンドウの[半径]を10にします。
円柱を複製します。
フィーチャツリーのルートノードを選択します。
[ジオメトリ]-[フィーチャ]-[クローン]-[直線クローン]を選択します。
直線クローンを円柱に適用させるため、LinearCloneのグループ内に円柱を移動します。
円柱をLinearCloneにドラッグ＆ドロップします。
LinearCloneを選択します。
[フィーチャプロパティ]ウィンドウの[カウント]を7にします。
[ステップ]を40にします。
[方向]で、押し出す方向を変更します。
Vectorの()内の数値は、XYZの順に押し出す方向を定義できます。
+X軸方向に複製するため、[方向]のXを1のままにします。
円柱を再度複製します。
[ジオメトリ]-[フィーチャ]-[クローン]-[直線クローン]を選択します。
円柱をLinearClone_1にドラッグ＆ドロップします。
LinearClone_1を選択します。
[フィーチャプロパティ]ウィンドウの[カウント]を2にします。
[ステップ]を100にします。
+Y軸方向に複製するため、[方向]のXを0、Yを1にします。
円柱を使用してパレットに穴を空けるため、フィーチャツリーの円柱をBlockの下に移動します。
LenearCloneを選択し、Blockの下にドラッグ＆ドロップします。
LenearCloneを選択します。
[原点]-[移動]を選択します。
ピンク色の丸を中央の円柱の底面にドラッグ&ドロップします。
Rx、Ry、Rzを0にし、適用ボタンをクリックします。
ピンク色の丸をパレットの中央にドラッグします。
[フィーチャプロパティ]ウィンドウのYを-50、Zを-40にします。
円柱で穴の形に型抜きします。
フィーチャツリーのTransformを選択します。
[ジオメトリ]-[フィーチャ]-[その他]-[ブール型]を選択します。
BlockとLenearCloneを選択し、Booleanにドラッグ＆ドロップします。
Booleanを選択します。
[フィーチャプロパティ]ウィンドウの[演算処理]で[引き算]を選択します。
3Dワールドを確認すると、穴の空いたパレットが作成されたことがわかります。
製品の合体や型抜きをする方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

製品の素材によってコンベアのルートを変更しよう(1/3)

分岐があるコンベアに、RoutingRule機能を設定して、製品のプロパティの値によってルートを変更する方法
https://youtu.be/G93yuEqHyTU
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_095_p1.zip

製品の素材によってコンベアのルートを変更する方法を説明します。
製品のルートを設定するには、2つの方法があります。
1つは、eカタログのコンポーネントの設定を使用する方法です。
もう1つは、ビヘイビアの設定とPythonスクリプトを使用して、ロジックを作成する方法です。
Part1では、eカタログのコンポーネントの設定を使用する方法について説明します。
eカタログの[タイプ別モデル]-[Component Templates]を選択します。
[Conveyor Template]を追加します。
[Split Conveyor Template]を追加します。
[マニピュレーション]-[PnP]を選択し、「Split Conveyor」を選択すると、黄色い三角形が3つ表示されます。
これらは、別のコンベア等に接続できる部分です。
外側から内側に向いている矢印は、ワークを搬入することができます。
内側から外側に向いている矢印2つのどちらかから、ワークを搬出する時、ワークを方向転換させることができます。
[コンポーネントプロパティ]ウィンドウの[TurnRight]にチェックを入れ、何もない空間を選択し、再びSplit Conveyorを選択すると、矢印の向きを変更することができます。
今回は、チェックは入れず、矢印をR側とB側のままにします。
[マニピュレーション]-[PnP]が選択された状態で、コンベアのR側にSplit Conveyorを接続します。
Conveyor Templateを右クリックし、コピーします。
3Dワールドを右クリックし、貼り付けます。
コピーしたConveyor TemplateをSplit ConveyorのR側に接続します。
再度、3Dワールドを右クリックし、貼り付けます。
コピーしたConveyor TemplateをSplit ConveyorのB側に接続します。
eカタログの[タイプ別モデル]-[Feeders]を選択します。
[Advanced Feeder]を追加します。
[Advanced Feeder]は、ワークとしてラインに流すコンポーネントの作成やプロパティの作成ができます。
[マニピュレーション]-[PnP]が選択された状態で、最初に追加したConveyor Templateに接続します。
[コンポーネントプロパティ]ウィンドウの[既定]タブの[CreationMode]を確認すると、[Distribution]がデフォルトで選択されています。
[Distribution]は、[DistributionBook]タブの機能を使用して、作成するワークの詳細を設定することができます。
[DistributionBook]タブを開きます。
[Note]の[エディタで開く]は、ワーク設定用のノートを開いて、設定を編集することができます。
Advanced Feederを選択時に、3DワールドのFeeder付近に表示されるオレンジのアイコンをクリックすることで、編集することもできます。
アイコンをクリックすると、ノートが表示されます。
ワークの設定がデフォルトで用意されています。
6行目に「First 4 Columns are reserved.」と記述されています。
15行目以降を確認すると、最初の4列は、ワークとして生成するコンポーネントの出現確率、ID、色、インデックス番号のために使用されていることがわかります。
7行目に「Next columns are customizable properties」と記述されています。
15行目以降の5列目を確認すると、コンポーネントに追加できるカスタマイズ可能なプロパティが記述されていることがわかります。
8行目から11行目には、カスタマイズ可能なプロパティで使用できるタイプが記述されています。
実数、整数、文字列が使用できることがわかります。
15行目は、コンポーネントのプロパティが記述されています。
コンポーネントのプロパティを1つ追加します。
ProductMaterialと記述し、マテリアルを表示するプロパティを追加します。
16行目に色と同じ文字列を追加します。
16行目の色はredのため、redと記述します。
文字列として表示する場合は、シングルクォーテーションを付けます。
同様に、17行目の色はpurpleのため、purpleと記述し、18行目の色はwhiteのため、whiteと記述します。
ノートのウィンドウを閉じます。
シミュレーションを実行すると、紫のワークが生成されます。
シミュレーションを一時停止します。
紫のワークを選択します。
[コンポーネントプロパティ]ウィンドウに[ProductMaterial]が追加されており、[purple]と表示されていることがわかります。
シミュレーションをリセットします。
ワークがSplit Conveyorを通る際に、マテリアルによってルートが変わるように設定します。
Split Conveyorを選択します。
[コンポーネントプロパティ]ウィンドウの[RoutingRule]を展開します。
デフォルトでルールが設定されているため、削除します。
[環状ルール]にマウスオーバーすると、削除ボタンが表示されるため、クリックし、削除します。
[タイプ]でルールを選択します。
今回は、文字列でマテリアルのプロパティを作成したため、[文字列表ルール]を選択します。
プロパティ名はProductMaterialにしたため、[変数]に[ProductMaterial]と入力します。
[ProductMaterial]に対するルールを設定します。
[既定]では、デフォルトのルールを設定します。
今回は、R側のコンベアにワークがデフォルトで流れるようにするため、[OutPort1]を選択します。
[接続もしくはルールを追加]をクリックし、新しいルールを追加します。
白のワークが流れたときのルールを設定します。
[既定]の下のテキストボックスに[white]と入力します。
白のワークがB側のコンベアに流れるようにするため、[OutPort2]を選択します。
シミュレーションを実行します。
白以外のワークはR側のコンベアに流れ、白のワークはB側のコンベアに流れます。
紫と赤は[既定]のルールに従ってR側に流れ、白は指定したルールに従ってB側に流れていることがわかります。
シミュレーションをリセットします。
赤のワークにルールを追加します。
[コンポーネントプロパティ]ウィンドウの[RoutingRule]で[接続もしくはルールを追加]をクリックします。
[既定]の下のテキストボックスに[red]と入力します。
赤のワークがB側のコンベアに流れるようにするため、[OutPort2]を選択します。
シミュレーションを実行します。
紫のワークはR側のコンベアに流れ、白と赤のワークはB側のコンベアに流れます。
紫は[既定]のルールに従ってR側に流れ、白と赤は指定したルールに従ってB側に流れていることがわかります。
製品の素材によってコンベアのルートを変更する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

製品の素材によってコンベアのルートを変更しよう(2/3)

分岐があるコンベアに、パイソンスクリプト（Python）を追加して、製品のマテリアル（素材）を確認する方法と、ルートを変更する方法
https://youtu.be/C97Kzp1aDt4
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_095_p2.zip

製品の素材によってコンベアのルートを変更する方法を説明します。
パート1では、eカタログのコンポーネントの設定を使用する方法について説明しました。
パート2では、ビヘイビアの設定とPythonスクリプトを使用して、ロジックを作成する方法について説明します。
パート1で使用したファイル、もしくは、[Route Products By Material - Part1_after.vcmx]をダウンロードし、開きます。
[Advanced Feeder]を削除し、[Basic Feeder]を使用します。
eカタログの[タイプ別モデル]-[Feeders]を選択します。
[Basic Feeder]を追加します。
[マニピュレーション]-[PnP]が選択された状態で、コンベアのL側に接続します。
シミュレーションを実行すると、ベージュのワークが生成されます。
シミュレーションを一時停止します。
ベージュのワークを選択します。
[コンポーネントプロパティ]ウィンドウを確認すると、[マテリアル]に[beige]が割り当てられていることがわかります。
シミュレーションをリセットします。
Split Conveyorを選択します。
[コンポーネントプロパティ]ウィンドウの[Routing Rule]を展開します。
Part1で作成した[文字列表ルール]を削除します。
シミュレーションを実行すると、ベージュのワークが流れますが、Split Conveyor上で止まります。
ワークの流れる方向のルールを決めていないため、ワークが流れる方向が分からず、止まってしまいます。
シミュレーションをリセットします。
Split Conveyorにルールを設定します。
[モデリング]タブを開きます。
[コンポーネントグラフ]ウィンドウの[Split Conveyor Template]-[ビヘイビア]を展開します。
[RoutingRule]を使用して、ルールを設定することができます。
[RoutingRule]は、コネクタの追加や削除ができます。
[RoutingRule]を展開すると、Portが表示されます。
[InPort]を選択します。
[プロパティ]ウィンドウを確認すると、コンポーネントを受け取るための入力ポートと、送信するための出力ポートがあります。
RoutingRuleのタイプによっては、入力と出力の両方を行うポートを作成することもできます。
新しいルールは、ルーティングルールやPythonスクリプトを使用することで追加できます。
今回は、Pythonスクリプトを使用します。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
デフォルトで記述されているソースコードを1行目以外削除します。
comp = getComponent()と記述し、Pythonスクリプトを設定しているコンポーネントを取得します。
routingRule = comp.getBehaviour("RoutingRule")と記述し、ビヘイビアのRoutingRuleを取得します。
print routingRuleと記述し、[出力]ウィンドウにRoutingRuleの情報を表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウにRoutingRuleが、vcRoutingRuleというPython APIを使用していることが表示されます。
Python APIは、ヘルプから確認することができます。
[ヘルプ]タブをクリックします。
[パイソンAPI]をクリックすると、ヘルプダイアログが表示されます。
[目次]-[Japanese]-[vcRoutingRule]を開きます。
vcRoutingRuleは、コンポーネントを異なるコネクタに転送するためのルールを定義できます。
[イベント]をクリックすると、OnRouteがあります。
OnRouteは、コンポーネントがRoutingRuleに転送されると、トリガーされます。
Pythonスクリプトで、OnRouteイベントを使用します。
ヘルプダイアログを閉じます。
printを削除します。
routingRule.OnRoute = routeByMaterialと記述し、コンポーネントがRoutingRuleに転送されると、routeByMaterial関数をトリガーします。
def routeByMaterialと記述し、routeByMaterial関数を作成します。
第一引数はconnector、第二引数はcomponent、第三引数はbehaviourとします。
material = component.Materialと記述し、コンポーネントのマテリアル情報を取得します。
print material.Nameと記述し、[出力]ウィンドウにマテリアルの名前を表示します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ワークがSplit Conveyorに転送されると、[出力]ウィンドウにbeigeと表示されます。
ワークをダブルクリックします。
[コンポーネントプロパティ]ウィンドウの[既定]タブの[マテリアル]はbeigeのため、マテリアルの名前が[出力]ウィンドウに表示されたことがわかります。
シミュレーションをリセットします。
パイソンスクリプトを開きます。
print関数を削除します。
[ヘルプ]タブの[パイソンAPI]を開きます。
vcRoutingRuleにsetTargetがあります。
setTargetは、ワークを転送するポートを設定します。
ポートはインデックス番号で指定します。
ヘルプダイアログを閉じます。
Split Conveyorを選択します。
[RoutingRule]には3つのポートがあり、インデックス番号は、InPortが0番目、OutPort1が1番目、OutPort2が2番目になります。
今回は、OutPort1にワークを転送する設定をします。
index = 1と記述し、index変数を1にします。
routingRule.setTargetと記述し、ワークを転送するポートを指定します。
indexと記述し、1番目のポート、つまり、OutPort1に転送されるようにします。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ベージュのワークがR側のコンベアに流れます。
[コンポーネントグラフ]ウィンドウの[OutPort1]を選択します。
[プロパティ]ウィンドウの[接続]を確認すると、[接続]にOut1Path、[ポート]にInputが設定されています。
[Out1Path]を選択します。
[プロパティ]ウィンドウの[パス]にはMidとOut1が設定されており、+X軸方向にワークがInputされるため、正しく接続されていることがわかります。
Out1Interfaceを選択します。
[プロパティ]ウィンドウの[セクション]を展開します。
[セクションフレーム]にOut1が選択されています。
[Flowフィールド]を展開すると、[Container]にOut1Path、[PortName]にOutputが設定されています。
Out1Pathに沿ってワークがOut1でOutputされるため、正しく接続されていることがわかります。
OutPort2にワークが流れるように設定を変更します。
index = 1の1を削除し、2にします。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ベージュのワークがB側のコンベアに流れます。
製品の素材によってコンベアのルートをPythonスクリプトで変更する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

製品の素材によってコンベアのルートを変更しよう(3/3)

分岐があるコンベアに、パイソンスクリプト（Python）を追加して、プロパティやノートでルート変更ルールを編集する方法
https://youtu.be/kWM-e6IjsLw
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_095_p3.zip

製品の素材によってコンベアのルートを変更する方法を説明します。
パート2では、ビヘイビアの設定とPythonスクリプトを使用して、ロジックを作成する方法について説明しました。
パート3では、マテリアルのリストを作成し、ルートを変更する方法を説明します。
パート2で使用したファイル、もしくは、[Route Products By Material - Part2_after.vcmx]をダウンロードし、開きます。
[モデリング]タブを開きます。
SplitConveyorを選択します。
[コンポーネントグラフ]ウィンドウの[Split Conveyor Template]-[ビヘイビア]-[パイソンスクリプト]を開きます。
left Rule = ["red", "white", "blue"]と記述し、マテリアルのリストを作成します。
if material.Name in leftRule:index = 2と記述し、リスト内にマテリアルの名前があるとき、OutPort2にワークが転送されるようにします。
4行目のindex = 2を1にし、リスト内のマテリアル以外は、デフォルトでOutPort1にワークが転送されるようにします。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ベージュのワークはリストに入っていないため、R側のコンベアに流れます。
シミュレーションをリセットします。
パイソンスクリプトを開きます。
ベージュをリストに追加し、B側のコンベアに流れるようにします。
leftRuleにbeigeを追加します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ベージュのワークをリストに入れたため、B側のコンベアに流れます。
シミュレーションをリセットします。
マテリアルのリストを変更する際にパイソンスクリプトを修正せず、プロパティで変更できるように設定します。
[コンポーネントグラフ]ウィンドウのルートノードを選択します。
[プロパティ]-[ベーシック]-[文字列]を追加し、文字列のプロパティを作成します。
[プロパティ]ウィンドウの[名前]をRouteMaterialsLeftにします。
[値変化]の[再構築]にチェックを入れると、コンポーネントのジオメトリを再構築します。
プロパティがフィーチャやノード内の数式に使用されている場合にチェックを入れる必要があります。
今回は、再構築する必要がないため、チェックを外します。
RouteMaterialsLeftのプロパティに文字列を追加します。
[値]の[RouteMaterialsLeft]にred,white,blue,beigeを入力します。
閉じるボタンをクリックし、[プロパティ]ウィンドウを閉じます。
[コンポーネントグラフ]ウィンドウのルートノードを選択します。
[コンポーネントプロパティ]ウィンドウを確認すると、RouteMaterialsLeftのプロパティと文字列が追加されていることがわかります。
パイソンスクリプトを開きます。
6行目に記述したマテリアルのリストを削除します。
代わりに、プロパティのリストを使用します。
7行目のleftRuleを削除し、comp.RouteMaterialsLeftと記述し、プロパティのリストを取得します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ベージュのワークがプロパティのリストに入っているため、B側のコンベアに流れます。
シミュレーションをリセットします。
今回は、マテリアル名が文字列に含まれていますが、値のリストを取得する場合は、値毎に区切る必要があります。
パイソンスクリプトを開きます。
leftRule変数を追記します。
7行目のcomp.RouteMaterialsLeftを切り取り、6行目にペーストします。
.split()と記述し、文字列や値を単語や値毎に区切ります。
プロパティのリストでカンマを使用したため、ダブルクォーテーションの中にカンマを記述します。
7行目にleftRuleを追記します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ベージュのワークがプロパティのリストに入っているため、B側のコンベアに流れます。
[コンポーネントグラフ]ウィンドウのRouteMaterialsLeftを選択します。
[プロパティ]ウィンドウの[次の場合に修正を許可]で[シミュレーション]にチェックが入っています。
チェックを入れると、シミュレーション実行中に値を編集できます。
[コンポーネントグラフ]ウィンドウのルートノードを選択します。
[コンポーネントプロパティ]ウィンドウのRouteMaterialsLeftのbeigeを削除します。
ベージュのワークがリストから削除されたため、R側のコンベアに流れます。
シミュレーションをリセットします。
リストが長くなる場合は、ノートを使用し、パイソンスクリプトでノートの値を取得すると便利です。
ノートを追加します。
[動作設定]-[ビヘイビア]-[その他]-[ノート]を作成します。
[プロパティ]ウィンドウの[エディタで開く]ボタンをクリックすると、ノートダイアログが表示されます。
ノートにリストを記載します。
[コンポーネントグラフ]ウィンドウのルートノードを選択します。
[コンポーネントプロパティ]ウィンドウのRouteMaterialsLeftの値をコピーします。
ノートに貼り付けます。
パイソンスクリプトを開きます。
6行目に記述したプロパティのリストの取得を削除します。
5行目の下にnote = comp.getBehaviour("Note")と記述し、ノートのビヘイビアを取得します。
ノートの値を取得するため、.Noteと記述します。
7行目にnote.split(",")と記述し、文字列を区切ります。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ベージュのワークはリストに入っていないため、R側のコンベアに流れます。
シミュレーションをリセットします。
パイソンスクリプトを開きます。
7行目の下にprint leftRuleと記述し、[出力]ウィンドウにノートのリストを表示します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
最初のワークがSplitConveyorを通る際に、[出力]ウィンドウにノートのリストが表示されます。
シミュレーションをリセットします。
ノートにbeigeを追記します。
シミュレーションを実行します。
最初のワークがSplitConveyorを通る際に、[出力]ウィンドウにノートのリストが表示されます。
beigeを追記したため、beigeが表示されていることがわかります。
シミュレーション実行中にbeigeを削除しても、[出力]ウィンドウのリストが表示されず、ワークが流れる方向も変更されません。
ノートを閉じると、[出力]ウィンドウのリストが表示され、ワークが流れる方向が変更されるため、ノートが更新されたことがわかります。
シミュレーションをリセットします。
パイソンスクリプトを開きます。
print関数は不要のため、削除します。
note.update()を使用することで、リアルタイムで編集することも可能ですが、今回はそのままにします。
ビヘイビアのルーティングルール以外に、独自でルーティングのロジックを作成できます。
[プロパティ]-[ベーシック]-[ブール型]を追加し、ブール型のプロパティを作成します。
[プロパティ]ウィンドウの[名前]をRouteByMaterialにします。
[値変化]の[再構築]のチェックを外します。
[値]のRouteByMaterialにチェックを入れ、Trueにします。
閉じるボタンをクリックし、[プロパティ]ウィンドウを閉じます。
パイソンスクリプトを開きます。
routingRuleがトリガーされたときの処理を追加するため、def routeByMaterialにソースコードを追記します。
if not comp.RouteByMaterial:returnと記述し、RouteByMaterialがFalseの場合、処理を終了して、RoutingRuleの処理に戻ります。
comp.RouteByMaterialは、プロパティの情報を取得するのではなく、値を取得しています。
RouteByMaterialはTrueがデフォルトのため、notを付けて、RouteByMaterialがFalseの場合を条件にしています。
コンパイルボタンをクリックします。
[コンポーネントグラフ]ウィンドウのルートノードを選択します。
[コンポーネントプロパティ]ウィンドウの[RouteByMaterial]を確認すると、チェックが入っているため、Trueになっていることがわかります。
シミュレーションを実行します。
ベージュのワークがR側のコンベアに流れます。
[コンポーネントプロパティ]ウィンドウの[Note]タブを開きます。
[エディタで開く]ボタンをクリックし、ノートを開きます。
beigeを追記し、ノートを閉じると、ベージュのワークがB側のコンベアに流れます。
[コンポーネントプロパティ]ウィンドウの[既定]タブを開きます。
RouteByMaterialのチェックを外し、Falseにします。
RouteByMaterialがFalseの場合、routingRuleに戻りますが、ルールが設定されていないため、ワークが転送されません。
シミュレーションをリセットします。
スクリプトやGUIを組み合わせてルールを追加することもできます。
今回は、[コンポーネントプロパティ]ウィンドウのRoutingRuleを使用します。
[RoutingRule]を展開します。
ワークがR側とB側のコンベアを交互に流れるようにします。
[タイプ]で[環状ルール]を選択します。
[接続もしくはルールを追加]をクリックし、新しいルールを追加します。
1番目のワークをR側のコンベアに流すため、OutPort1を選択します。
[接続もしくはルールを追加]をクリックし、新しいルールを追加します。
2番目のワークをB側のコンベアに流すため、OutPort2を選択します。
シミュレーションを実行します。
RouteByMaterialにチェックが入っておらず、Falseのため、RoutingRuleの環状ルールが処理され、ワークがR側とB側のコンベアを交互に流れます。
RouteByMaterialにチェックを入れ、Trueにします。
ノートのリストにbeigeがあるため、パイソンスクリプトの10行目が処理され、ワークがB側のコンベアに流れます。
製品の素材によってコンベアのルートを変更する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

製品の摩擦を変更しよう(1/2)

物理の影響を受ける製品の、静止摩擦、動摩擦の摩擦力の設定方法
https://youtu.be/7IOTn8hQB1E
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_081_p1.zip

製品の摩擦力を変更する方法を説明します。
スロープから円柱を落とし、円柱の摩擦力の確認や変更を行います。
スロープを作成します。
eカタログの[タイプ別モデル]-[Physics]を選択します。
[Arrows Colider]を追加します。
[コンポーネントプロパティ]ウィンドウのRxを90にし、X軸に沿って円柱を90°回転します。
[Length]を1500に変更し、傾斜を緩やかにします。
円柱を追加します。
eカタログの[タイプ別モデル]-[Physics]-[Cylinder Colider]を追加します。
[ツール]-[スナップ]を選択し、円柱をスロープの上面に移動します。
傾斜に合わせて斜めになりました。水平に戻します。
[コンポーネントプロパティ]ウィンドウで、Y軸を中心とした回転を0にします。
Ryのアイコンをクリックすると、0になります。
[マニピュレーション]-[移動]を選択し、円柱のZ座標が約1000になるよう、+Z軸方向に移動します。
シミュレーションを実行すると、物理演算がオンになりますが、円柱は落下しません。
物理の影響を受けるコンポーネントを作るには、物理エンティティビヘイビアを追加する必要があります。
シミュレーションをリセットし、円柱に物理設定をします。
[コンポーネントプロパティ]ウィンドウの[PhysicsEntity]タブを開きます。
[物理タイプ]を確認すると、デフォルトで[機構]が選択されています。
[物理タイプ]を[物理内]に設定します。
[物理内]は、重力やコンポーネントに外力が加わることで、コンポーネントが動作します。
シミュレーションを実行します。
円柱がスロープに落下し、滑り落ちた後、転がります。
シミュレーションをリセットします。
摩擦は、円柱がスロープに衝突するときの弾性力、スロープ上に円柱を維持させるための摩擦力、円柱の運動力と速度を考慮する必要があります。
円柱をより高い位置から落下させると速度が大きくなり、衝突するときの弾性力も強くなりますが、それには摩擦が影響しています。
円柱を低い位置から落とすと、どのように動作するのか確認します。
[マニピュレーション]-[移動]が選択された状態で、円柱のZ座標が約600になるよう、-Z軸方向に移動します。
シミュレーションを実行します。
円柱がスロープに落下し、滑り落ちた後、転がります。
高い位置から落下させた場合に比べ、摩擦の影響が大きくなり、滑り落ちる速度が遅くなったことがわかります。
シミュレーションをリセットします。
円柱を高い位置から落とすと、どのように動作するのか確認します。
[マニピュレーション]-[移動]が選択された状態で、円柱のZ座標が約2000になるよう、+Z軸方向に移動します。
シミュレーションを実行します。
円柱がスロープに落下し、滑り落ちた後、転がります。
低い位置から落下させた場合に比べ、摩擦の影響が小さくなり、滑り落ちる速度が速くなったことがわかります。
シミュレーションをリセットします。
円柱の高さを約700にします。
[マニピュレーション]-[移動]が選択された状態で、円柱のZ座標が約700になるよう、-Z軸方向に移動します。
シミュレーションを実行します。
円柱がスロープに落下し、滑り落ちた後、転がります。
シミュレーションをリセットします。
円柱がスロープを滑り落ちた後、転がらないよう、摩擦の設定を調整します。
[モデリング]タブを開きます。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]がオンになっていることを確認します。
[Cylinder Colider]-[ビヘイビア]-[PhysicsEntity]を選択します。
[プロパティ]ウィンドウを確認すると、[静止摩擦]と[動摩擦]の項目があります。
静止摩擦は、物体が静止している時に働く摩擦力のことです。
動摩擦は、物体が動いている時に働く摩擦力のことです。
デフォルトでは、0.5が入力されています。
静止摩擦と動摩擦は摩擦係数で表されるため、数値は0～1の範囲になり、数値が大きいほど摩擦力は大きくなります。
動摩擦と静止摩擦に0を入力します。
シミュレーションを実行します。
円柱がスロープに落下し、滑り落ちた後、摩擦力が小さくなったため、そのまま転がらず遠くまで滑ります。
シミュレーションをリセットします。
摩擦力を調整する場合は、段階的に数値を変化させると、調整しやすいです。
通常、まずはデフォルトでテストし、次に全ての摩擦力を0にしてテストし、その後、静止摩擦が1、動摩擦が0の場合のテストを行います。
静止摩擦に1を入力します。
シミュレーションを実行します。
円柱がスロープに落下し、摩擦で止まります。
シミュレーションをリセットします。
静止摩擦に0、動摩擦に1を入力します。
シミュレーションを実行します。
円柱がスロープに落下し、摩擦で止まります。
シミュレーションをリセットします。
動摩擦を半分の数値にします。
動摩擦に0.5を入力します。
シミュレーションを実行します。
円柱がスロープに落下し、滑り落ちた後、転がります。
シミュレーションをリセットします。
円柱が転がらないよう調整します。
動摩擦をさらに半分の数値にします。
動摩擦に0.25を入力します。
シミュレーションを実行します。
円柱がスロープに落下し、滑り落ちた後、そのまま転がらず滑ります。
シミュレーションをリセットします。
円柱の角度を変更し、動作に問題がないか確認します。
[コンポーネントグラフ]ウィンドウのルートーノードを選択します。
[マニピュレーション]-[移動]が選択された状態で、円柱のRxが約-35になるよう、X軸に沿って円柱を回転します。
シミュレーションを実行します。
円柱がスロープに落下し、滑り落ちた後、転がります。
シミュレーションをリセットします。
動作に問題がないようにみえますが、摩擦の設定を変更し、動作の変化を確認します。
[コンポーネントグラフ]ウィンドウの[PhysicsEntity]を選択します。
静止摩擦に1、動摩擦に0を入力します。
シミュレーションを実行します。
円柱がスロープに落下し、スロープ上をカーブしながら、側面から落下します。
シミュレーションをリセットします。
スロープの側面から落下しないよう調整します。
静止摩擦を半分の数値にします。
静止摩擦に0.5を入力します。
シミュレーションを実行します。
円柱がスロープに落下し、スロープ上をカーブしながら、滑り落ちる途中でスロープの側面から落下します。
シミュレーションをリセットします。
静止摩擦をさらに半分の数値にします。
静止摩擦に0.25を入力します。
シミュレーションを実行します。
円柱がスロープに落下し、滑り落ちますが、スロープを滑り切る直前に、側面から落下します。
シミュレーションをリセットします。
円柱がスロープ上をカーブせず、滑る勢いを維持するためには、動摩擦が必要です。
動摩擦に0.25を入力します。
シミュレーションを実行します。
円柱がスロープに落下し、滑り落ちますが、スロープを滑り切る直前に、側面から落下します。
シミュレーションをリセットします。
動摩擦を2倍の数値にします。
動摩擦に0.5を入力します。
シミュレーションを実行します。
円柱がスロープに落下し、スロープ上をカーブしながら、滑り落ちる途中でスロープの側面から落下します。
シミュレーションをリセットします。
動摩擦をさらに2倍の数値にします。
動摩擦に1を入力します。
シミュレーションを実行します。
円柱がスロープに落下し、スロープ上をカーブしながら、側面から落下します。
シミュレーションをリセットします。
円柱のカーブが強くなったため、動摩擦を0.5に戻します。
動摩擦を一通り調整したため、静止摩擦を変更して調整します。
静止摩擦に0.1を入力します。
シミュレーションを実行します。
あまり動作に変化がみられないことがわかります。
シミュレーションをリセットします。
静止摩擦に0.3を入力します。
シミュレーションを実行します。
スロープ上でのカーブが少し強くなり、先ほどよりも速くスロープの側面から落下します。
シミュレーションをリセットします。
静止摩擦の数値を大きくするとカーブが強くなることがわかったため、静止摩擦を0に戻します。
シミュレーションを実行します。
円柱がスロープに落下し、スロープ上をカーブしながら、滑り落ちる途中でスロープの側面から落下します。
シミュレーションをリセットします。
動摩擦に0.25を入力します。
シミュレーションを実行します。
円柱がスロープに落下し、スロープ上から途中で落下することなく、滑り切ることがわかります。
シミュレーションをリセットします。
製品の摩擦力を変更する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

製品の摩擦を変更しよう(2/2)

物理の影響を受ける製品の摩擦力を変更した時の、軌跡を保存する方法
https://youtu.be/6RVrJqjkzSU
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_081_p2.zip

製品の摩擦力を変更する方法を説明します。
シミュレーション中に円柱が移動する際の軌跡を表示するように設定します。
パート1で作成した円柱とスロープ、もしくは、[Static and Dynamic Friction - Part1_after.vcmx]をダウンロードし、開きます。
円柱が宙に浮いている状態のため、スロープに円柱が置かれている状態にします。
円柱を選択します。
[モデリング]タブを開きます。
[コンポーネントグラフ]ウィンドウのルートノードを選択します。
円柱を水平にします。
[コンポーネントプロパティ]ウィンドウのRxを0にし、X軸を中心にした回転を0にします。
Rxのアイコンをクリックすると、0になります。
[ツール]-[スナップ]を選択し、円柱をスロープの上面に移動します。
シミュレーションを実行します。
円柱がスロープ上を滑り落ちた後、床の上で止まります。
シミュレーションをリセットします。
シミュレーション中の円柱の一連の動作を可視化します。
ロボットを使用することで、シミュレーション中の動作を可視化することができます。
[ホーム]タブを開きます。
eカタログの[タイプ別モデル]-[Robots]を展開します。
[Visual Components]を選択します。
[Generic Articulated Robot]を追加します。
ロボットのプログラムを使用して、円柱の軌跡を可視化します。
ロボットの信号を使用し、軌跡の動作設定をします。
[コンポーネントプロパティ]ウィンドウの[アクション設定]を展開します。
[シグナルアクション]が表示されるため、[出力]で81を選択します。
[Generic Articulated Robot]のシグナル81は、[オントゥルー]に掃引ボリュームオン、[オンフォルス]に掃引ボリュームオフがデフォルトで選択されています。
掃引ボリュームは、指定したジオメトリの軌跡を描画することができるため、デフォルトのままにします。
[掃引ボリュームオン]の[SweptGeometry]にロボットがデフォルトで選択されています。
SweptGeometryは、軌跡を描画したいジオメトリを指定できます。
ロボットではなく円柱の軌跡を可視化するため、ジオメトリを変更します。
入力エリアをクリックし、[Generic Articulated Robot]を削除します。
プラスボタンの横のアイコンを選択し、3Dワールド上のコンポーネントをクリックして、ジオメトリを選択できます。
アイコンをクリックします。
3Dワールドにマウスポインターを移動させると、選択できるノードを示す赤い境界線のボックスが表示されます。
円柱を選択します。
[コンポーネントプロパティ]ウィンドウの[SweptGeometry]を確認すると、円柱が選択されたことがわかります。
[Material]で軌跡の色を変更します。
軌跡の色が分かりやすいよう、透明の色を使用します。
[transp_red]を選択し、透明な赤色にします。
ロボットのプログラムに設定した信号を使用し、軌跡を出力するための設定をします。
[プログラム]タブを開きます。
[プログラムエディタ]ウィンドウの[サブプログラム]-[Main]に[セットバイナリ出力ステートメント]を追加します。
[ステートメントプロパティ]の[バイナリ出力ステートメント]に81を入力し、軌跡を可視化する信号を設定します。
[出力値]にチェックを入れて、Trueにします。
シミュレーションを実行します。
円柱がスロープを滑り落ちる動作に合わせて、透明の赤い色で軌跡が表示されます。
軌跡を確認すると、円柱の滑り始めはスピードが遅く、徐々に加速が付いて速くなっていることがわかります。
シミュレーションをリセットすると、軌跡の表示が消えます。
円柱の動摩擦を変更し、軌跡の違いを確認します。
[モデリング]タブを開きます。
円柱を選択します。
[コンポーネントグラフ]ウィンドウの[Cylinder Colider]-[ビヘイビア]-[PhysicsEntity]を選択します。
動摩擦を半分の数値にします。
動摩擦に0.125を入力します。
シミュレーションを実行します。
軌跡を確認すると、先ほどよりも円柱が滑るスピードが速くなっていることがわかります。
シミュレーションをリセットします。
動作の変化をわかりやすくするため、動摩擦に0を入力します。
シミュレーションを実行します。
軌跡を確認すると、先ほどよりもさらに円柱が滑るスピードが速くなっていることがわかります。
また、摩擦が0になったため、円柱が止まるまでの距離が長くなっています。
シミュレーションをリセットします。
軌跡の変化をわかりやすくするため、シミュレーションをリセットした後も軌跡が残るようにします。
[プログラム]タブを開きます。
円柱の軌跡を4秒間表示するよう設定します。
[プログラムエディタ]ウィンドウの[サブプログラム]-[Main]に[遅延ステートメント]を追加します。
[ステートメントプロパティ]ウィンドウの[遅延]に4を入力し、4秒間遅延させます。
[セットバイナリ出力ステートメント]を追加し、4秒後に軌跡の表示をオフにします。
[ステートメントプロパティ]の[バイナリ出力ステートメント]に81を入力し、軌跡を可視化する信号を設定します。
[出力値]にチェックは入れず、Falseにします。
4秒間表示した軌跡が、シミュレーションリセット後もジオメトリとして残るよう設定します。
ロボットを選択します。
[コンポーネントプロパティ]ウィンドウの[アクション設定]を展開します。
[シグナルアクション]が表示されるため、[出力]で81を選択します。
[掃引ボリュームオフ]の[StoreGeometry]にチェックを入れ、シミュレーション中に作成した軌跡を保存します。
[掃引ボリュームオン]の[AttachTo]で作成した軌跡を描画する場所を選択します。
[Node]は、信号を発信しているロボットに描画されます。
[Closet]は、ツールフレームを使用して、信号を発信しているロボットによって検出されるコンポーネントに描画されます。
[NewComponent]は、新規コンポーネントに描画されます。
通常は[NewComponent]を選択します。
シミュレーションを実行し、ロボットプログラムが終了するまで約4秒間待機します。
プログラムの終了後、シミュレーションが停止します。
シミュレーションをリセットします。
新規コンポーネントとして軌跡が生成されたので、軌跡を比較するため、シミュレーションの妨げにならない位置に移動します。
[ホーム]タブを開きます。
軌跡を選択します。
[マニピュレーション]-[移動]を選択し、+Y軸方向に移動します。
動摩擦を変更し、軌跡を比較します。
[モデリング]タブを開きます。
円柱を選択します。
[コンポーネントグラフ]ウィンドウの[PhysicsEntity]を選択します。
動摩擦に0.25を入力します。
シミュレーションを実行し、ロボットプログラムが終了するまで約4秒間待機します。
プログラムの終了後、シミュレーションが停止します。
シミュレーションをリセットします。
新規コンポーネントとして軌跡が生成されたので、軌跡を比較するため、シミュレーションの妨げにならない位置に移動します。
[ホーム]タブを開きます。
軌跡を選択します。
[マニピュレーション]-[移動]を選択し、+Y軸方向に移動します。
軌跡の違いをわかりやすくするため、軌跡の色を変更します。
[モデリング]タブを開きます。
[ジオメトリ]-[ツール]-[マテリアル]-[割り当て]を選択します。
[マテリアルを割り当て]ウィンドウの[ライブラリ]タブを選択します。
[マテリアル]の検索ボックスにtranspと入力し、透明のマテリアルを表示します。
transp_greenを選択します。
[次のものにマテリアルを設定]の[フィーチャ]を選択します。
動摩擦を0.25にした場合の軌跡を選択すると、軌跡が透明の緑色になります。
製品の摩擦力を変更する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

製品をハイライトして強調しよう

製品をハイライトにするなどの色の変更をして、強調して表示する方法
https://youtu.be/MnsVTvJ_Zes
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_102.zip

製品をハイライトして強調する方法を説明します。
重要な製品や、壊れている製品の色を変更することで、強調して表示することができます。
コンベアにワークを流し、ワークをハイライト表示します。
eカタログの[タイプ別モデル]-[Feeders]を開きます。
[Basic Feeder]を追加します。
eカタログの[タイプ別モデル]-[Components Template]を開きます。
[Conveyor Template]を追加します。
[マニピュレーション]-[PnP]が選択された状態で、フィーダーとコンベアを接続します。
フィーダーを選択します。
[コンポーネントプロパティ]ウィンドウの[Interval]に2を入力し、ワークが流れる間隔を短くします。
コンベアを選択します。
[モデリング]タブを開きます。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を選択します。
[動作設定]-[ビヘイビア]-[シグナル]-[ブール型]を選択し、[BooleanSignal]を追加します。
シグナルを条件にスクリプトを処理したい場合は、Python Scriptと接続した信号を使用することができます。
[プロパティ]ウィンドウの[接続]をクリックします。
プラスボタンが表示されるため、クリックすると、[Add 'Connections' items]ダイアログが表示されます。
[Python Script]を選択すると、[接続]に追加されたことがわかります。
[Add 'Connections' items]ダイアログを閉じます。
[コンポーネントグラフ]ウィンドウの[MainPath]を選択します。
[MainPath]は、コンベア上のInFrame、MidFrame、OutFrameを通るパスです。
パスにワークが入ったときと出たときの情報を取得するため、トランジションシグナルを定義します。
[プロパティ]ウィンドウの[トランジションシグナル]で[BooleanSignal]を選択します。
パスにワークが入ったときはシグナルがTrue、パスからワークが出たときはシグナルがFalseになります。
コンベアのパスに最初に入ったワークをハイライトします。
パイソンスクリプトを開きます。
今回は使用しないため、OnSignal関数を削除します。
app = getApplication()と記述し、アプリケーション情報を取得します。
yellow = app.findMaterial("yellow")と記述し、黄色のマテリアルを取得します。
comp = getComponent()と記述し、Pythonスクリプトを設定しているコンポーネントを取得します。
path = comp.findBehaviour("MainPath")と記述し、ビヘイビアのMainPathを取得します。
transition_signal = path.TransitionSignalと記述し、トランジションシグナルの情報を取得します。
OnRun内のpassを削除します。
while True:と記述し、ループ処理します。
if transition_signal.Value == True:と記述し、トランジションシグナルがTrueになったとき、つまり、コンベアのパスにワークが入ったときを条件とします。
part = path.getComponent(0)と記述し、0番目、つまり、最初のワークを指定します。
part.NodeMaterial = yellowと記述し、ワークのマテリアルを黄色にします。
ワークのフィーチャに既にマテリアルが指定されている場合、強制的に指定したマテリアルを割り当てるよう定義します。
part.MaterialInheritance=と記述し、マテリアルの管理方法を定義します。
0番目のワークのノードとその子ノードのジオメトリにマテリアルを割り当てるため、VC_MATERIAL_FORCE_INHERITと記述します。
プログラムの処理時間を確保するため、delay(0.1)と記述し、0.1秒遅延させます。
else: delay(0.1)と記述し、条件以外の場合は0.1秒遅延させます。
コンパイルボタンをクリックします。
シミュレーションを実行します。
最初のワークが黄色になります。
黄色のワークがコンベアから出ると、代わりに先頭のワークが黄色になります。
シミュレーションをリセットします。
コンベアのパスに入った全てのワークをハイライトします。
パイソンスクリプトを開きます。
ハイライトするワークを指定している12行目を削除します。
12行目にfor part in path.Components:と記述し、変数のpartにコンベアのパスに入ったワークの情報を格納します。
13行目～15行目をインデントし、コンベアのパスに入った全てのワークに黄色を割り当てます。
コンパイルボタンをクリックします。
シミュレーションを実行します。
コンベアに入った全てのワークが黄色になります。
シミュレーションをリセットします。
for文を使用する方法は、ワークがパスから離れた場合や大量のコンベアをコード内で処理する場合は、シミュレーション時に負荷が掛かる可能性があります。
そこで、OnTransitionイベントを使用します。
OnTransitionは、コンポーネントがコンテナ間を移動したときに処理されるイベントです。
パイソンスクリプトを開きます。
path.OnTransition = highlightPartEnteringPathと記述し、ワークがコンテナ間を移動したときに、highlightPartEnteringPathという関数を呼び出します。
def highlightPartEnteringPathと記述し、highlightPartEnteringPathの関数を作成します。
第一引数はコンポーネントの情報を格納する変数を定義します。
第一引数はpartとします。
第二引数はコンポーネントがコンテナに到着したときにTrue、離れたときにFalseとなるブール型の変数を定義します。
第二引数はisPartArrivingとします。
if isPartArriving == True:と記述し、ワークがコンベアに到着したときを条件とします。
ワークがコンベアに到着したときに黄色にハイライトするため、OnRun内のpart.NodeMaterialとpart.MaterialInheritanceをコピーし、if文内に貼り付けます。
OnRun内の処理は不要なため、削除し、passと記述します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
コンベアに入った全てのワークが黄色になります。
シミュレーションをリセットします。
黄色にハイライトしたワークを元のマテリアルにリセットします。
OnPhysicalTransitionイベントを使用します。
OnPhysicalTransitionは、コンポーネントの前の端がパスに入るときと、コンポーネントの後ろの端がパスから出るときに処理されるイベントです。
パイソンスクリプトを開きます。
path.OnPhysicalTransition = undoHighlightPartLeavingPathと記述し、コンポーネントが出入りしたときに、undoHighlightPartLeavingPathという関数を呼び出します。
def undoHighlightPartLeavingPathと記述し、undoHighlightPartLeavingPathの関数を作成します。
第一引数は第二引数のコンポーネントが使用しているコンテナの変数を定義します。
第一引数はpathとします。
第二引数はコンポーネントの情報を格納する変数を定義します。
第二引数はpartとします。
第三引数はコンポーネントがパスに入っているときにTrue、出ているときにFalseとなるブール型の変数を定義します。
if isPartArriving == True:と記述し、ワークがコンベアに入ったときを条件とします。
ワークがコンベアに入ったときにワークの元の素材を取得します。
素材は、変数にリストとして保存しておくと便利です。
undoHighlightPartLeavingPath関数の前に、original_materials = {}と記述し、素材のリストの変数を用意します。
if文の下にoriginal_materials[part] = part.NodeMaterialと記述し、ワークの元の素材をリストに格納します。
elif isPartArriving == False:と記述し、ワークがコンベアから出たときを条件とします。
ワークがコンベアから出たときに元の素材に戻すため、part.NodeMaterial = original_materials.get(part)と記述し、素材のリストから元の素材を取得します。
ワークのノードとその子ノードのジオメトリにマテリアルを割り当てるため、VC_MATERIAL_FORCE_INHERITと記述します。
コンパイルボタンをクリックします。
ワークがコンベアから出たときに元の素材に戻っていることを確認するため、コンベアを追加します。
[ホーム]タブを開きます。
eカタログの[タイプ別モデル]-[Components Template]を開きます。
[Offset Conveyor Template]を追加します。
[マニピュレーション]-[PnP]が選択された状態で、Conveyor TemplateにOffset Conveyor Templateを接続します。
シミュレーションを実行します。
Conveyor Templateに入ったワークが黄色になり、Conveyor Templateから出たワークが元の素材の色になります。
製品をハイライトして強調する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

操作盤を作ってみよう(1/3)

オリジナルの操作盤を作る方法（3DCADファイルをインポート、動的に表示を切り替え可能にする）
https://youtu.be/phuJjvI-fmw
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_115_p1.zip

操作盤を作成する方法について説明します。
設定が完了すると、操作盤のボタン操作によって、画面表示の切り替えと、事前に用意されたモデルに移動指令を出すことができます。
本動画では、操作盤のCADファイルをインポートし、画面の表示を切り替える方法を説明します。
[Operation Panel_before.vcmx]を開きます。
レール上をブロックが移動する設定済みのモデルが、表示されます。
CADファイルをインポートします。
[ホーム]タブ、または[モデリング]タブをクリックします。
[インポート]グループの[ジオメトリ]をクリックすることで、CADファイルをインポートできます。
[Operation Panel.step]を選択し、[開く]をクリックします。
[モデルをインポート]ウィンドウでは、インポート時のプロパティを設定できます。
[構造]は、モデルを分割する方法を設定できます。
[フィーチャ]は、分割せず、[ノード]は、ジオメトリをすべて別のノードに分割します。
[コンポーネント]は、ジオメトリをすべて別のコンポーネントに分割します。
単一のモデルをインポートする場合、[フィーチャ]か[ノード]を選択します。
レイアウトをインポートする場合、[コンポーネント]を選択します。
[Operation Panel.step]は、単一のモデルとしてインポートするため、[フィーチャ]を選択します。
3Dワールドに表示されるモデルは、多数の三角形で構成されており、[テッセレーションの品質]は、三角形の個数を設定できます。
モデルのデータ量に応じて品質を変更します。
低品質にすることで、モデルのデータ量を削減できます。
今回のモデルは、データ量が少ないため、[中位品質]に設定します。
[含める]では、インポート時のジオメトリに含む要素を設定できます。
今回は、[マークアップ]と[マテリアル]と[テクスチャー]を選択します。
[マテリアル作成ルール]では、マテリアルライブラリを作成するためのルールを設定できます。
今回は、[常にライブラリから最も近似のものを使用します]を選択します。
[フィーチャツリー]は、フィーチャツリーの作成方法を、設定できます。
[完全]は、トランスフォームフィーチャを使用し、CADファイルと階層構造を完全に一致させます。
[最適化]は、すべてのジオメトリを同じ階層にし、[最小化]は、ジオメトリを1つにまとめることができます。
ボタンを操作盤から分割するため、フィーチャツリーをシンプルな状態にします。
[最適化]を選択します。
[ジオメトリを整理]では、ジオメトリセットを作成するためのルールを設定できます。
ジオメトリセットは、フィーチャツリーの各ジオメトリの中に含まれるジオメトリのまとまりです。
メッシュを構成する三角ポリゴンの3点の合計が10000を超えると、新しいジオメトリセットが作成されます。
[面による]は、面ごとに、[マテリアルによる]は、マテリアル事にジオメトリセットを作成できます。
[折りたたみ]は、ジオメトリセットを1つにまとめ、[数学的データ]は、曲線のジオメトリセットを作成できます。
今回は、[マテリアルによる]を選択します。
[上軸]は、ジオメトリの上面と底面を整列させる軸を設定できます。
[上軸]で[+Z]を選択し、[インポート]をクリックします。
3Dワールドに、操作盤をインポートできたことがわかります。
操作盤が、3Dワールドの原点に配置されない場合、[コンポーネントプロパティ]ウィンドウの[座標]をすべて0に変更します。
操作盤の画面には、STARTとSTOPが重なった状態で表示されています。
表示する文字を切り替えられる仕組みにするため、[モデリング]タブを開いて設定します。
[ジオメトリ]グループの[フィーチャ]を展開し、[その他]から[スイッチ]を選択します。
スイッチは、子階層のフィーチャを有効化、または無効化できます。
3Dワールドで、STARTとSTOPを選択します。
コントロールキーを押した状態で、選択することで、複数のフィーチャを選択できます。
[コンポーネントグラフ]ウィンドウ下段でハイライトされたフィーチャを、スイッチにドラッグ＆ドロップします。
現在、スイッチの子階層にあるフィーチャは、すべて無効化されているため、文字は表示されません。
有効化するフィーチャを選択します。
スイッチを選択します。
[フィーチャプロパティ]ウィンドウの[選択]は、入力された値に応じて、有効化／無効化するフィーチャを選択できます。
子階層のフィーチャが複数ある場合、複数のフィーチャを、同時に有効化することはできません。
一度に有効化できるフィーチャは、1つのみです。
値がブール型の場合、Trueの時は1つ目の子フィーチャのみ有効化し、Falseの時はすべての子フィーチャを無効化します。
値が整数の場合、0の時は子階層のすべてのフィーチャを無効化します。
1以上の時は、子階層のフィーチャを番地で指定し、有効化できます。
値が実数の場合、小数点以下を切り捨て、有効化するフィーチャを番地で指定します。
値が文字列の場合、名前が一致したフィーチャを有効化できます。
[選択]に1と入力します。
スイッチの子階層の1番目にある、STOPのみ表示されます。
[選択]に2と入力します。
スイッチの子階層の2番目にある、STARTのみ表示されます。
[選択]にプロパティ名を入力し、プロパティの値から有効化するフィーチャを選択することもできます。
シミュレーション中に、操作盤の文字を切り替えるため、プロパティを追加します。
[プロパティ]グループの[プロパティ]を展開し、[ベーシック]から[整数]を選択します。
[プロパティ]ウィンドウで、名前をChangeに変更します。
[値]を1に変更します。
プロパティの値を参照し、画面の文字を切り替えます。
[コンポーネントグラフ]ウィンドウ下段のスイッチを選択します。
[フィーチャプロパティ]ウィンドウの[選択]に、Changeと入力します。
Changeの値が1であるため、表示される文字は、STOPです。
[コンポーネントグラフ]ウィンドウの[プロパティ]で、Changeを選択します。
[プロパティ]ウィンドウの[値]を2に変更し、エンターキーを押すと、表示される文字がSTARTに変化します。
操作盤の画面の表示を切り替える方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

操作盤を作ってみよう(2/3)

オリジナルの操作盤を作る方法（可動部を分割、押下可能にする）
https://youtu.be/th2zkgGSO7E
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_115_p2.zip

操作盤を作成する方法について説明します。
本動画では、操作盤のボタンを設定します。
本動画は、操作盤の画面の表示を切り替える方法の続きから設定します。
操作盤の画面の表示が設定されたファイル[Operation Panel1_after.vcmx]が必要です。
ボタンをクリックした時、ボタンが動作する仕組みにするため、プロパティを追加します。
操作盤を選択します。
[プロパティ]グループの[プロパティ]を展開し、[ベーシック]から[ブール型]を選択します。
ブール型プロパティは、オンオフを通知できます。
[プロパティ]ウィンドウで、名前をPressStartに変更します。
同様に、ブール型プロパティを追加し、名前をPressStopに変更します。
ボタンを、プロパティの値によって、動作できるようにするため、可動部として設定します。
緑のボタンをスタートボタン、赤のボタンをストップボタンとします。
スタートボタンを選択し、右クリックします。
メニューから[抽出]、[抽出リンク]を選択することで、選択したジオメトリを新しいノードに抽出できます。
[コンポーネントグラフ]ウィンドウに、「Link_1」が追加されたことがわかります。
Link_1に動作の詳細を設定します。
[リンクプロパティ]ウィンドウで、[JointType]を設定することで、動作の種類を定義できます。
[固定]は、動作を設定せず、ノードを定義した位置に固定できます。
[回転]は、定義した軸を中心に回転運動、[直進]は、軸に沿って直線運動できます。
[回転フォロワー]は、別のノードの運動量と連動した回転運動ができます。
[直進フォロワー]も[回転フォロワー]と同様に、別のノードと連動した直線運動です。
[カスタム]は、定義した軸を基準に、回転または直線運動できます。
今回は、[カスタム]を選択します。
可動部が動作できる範囲を設定します。
[最小リミット]と[最大リミット]は、可動部が動作できる範囲の最小値と最大値です。
[最小リミット]を0、[最大リミット]を20に変更します。
可動部が動作する位置と条件を設定します。
[Joint]は、可動部が直線運動するための、数式を入力できます。
PressStartの値がTrueの時、ボタンを押し込み、Falseの時、ボタンを元の位置に戻します。
[Joint]に、PressStart?Ty(20):Ty(0)と入力します。
クエスチョンマーク以前の条件式がTrueの場合、コロンより前の数式を実行します。
条件式がFalseの場合、コロンより後の数式を実行します。
PressStartの値を変更し、動作を確認します。
[コンポーネントグラフ]ウィンドウで、PressStartを選択します。
[プロパティ]ウィンドウの、[PressStart]にチェックを付けます。
3Dワールドで、スタートボタンが押し込まれることを確認します。
[プロパティ]ウィンドウの、[PressStart]からチェックを外します。
3Dワールドで、スタートボタンが元の位置に戻ることを確認します。
同様に、ストップボタンに、PressStopの値によって動作する仕組みを設定します。
ストップボタンを選択します。
右クリックして、メニューを開きます。
[抽出]から[抽出リンク]を選択します。
[コンポーネントグラフ]ウィンドウに、「Link_2」が追加されたことがわかります。
Link_2に動作の詳細を設定します。
[リンクプロパティ]ウィンドウの、[JointType]で[カスタム]を選択します。
[最小リミット]を0、[最大リミット]を20に変更します。
[Joint]に、PressStop?Ty(20):Ty(0)と入力します。
PressStopの値を変更し、動作を確認します。
[コンポーネントグラフ]ウィンドウで、PressStopを選択します。
[プロパティ]ウィンドウの、[PressStop]にチェックを付けます。
3Dワールドで、ストップボタンが押し込まれることを確認します。
[プロパティ]ウィンドウの、[PressStop]からチェックを外します。
3Dワールドで、ストップボタンが元の位置に戻ることを確認します。
シミュレーション中に、マウスクリックすることで、ボタンを押せるようにするため、ジョグ情報を追加します。
「Link_1」を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[ジョグ情報]を選択します。
ジョグ情報は、自由度を定義することで、オブジェクトやプロパティと互いに作用し合うことができます。
PythonScriptで、ジョグ情報にアクセスすることで、オブジェクトの操作状況を確認できます。
ジョグ情報で、自由度を定義します。
[プロパティ]ウィンドウの[DOF]は、自由度を定義することができ、定義された軸を、移動、または回転の基準とします。
デフォルトの自由度は、Z軸を中心とした回転です。
ボタンが動作する方向を、Y軸方向の直進に定義するため、[TY]を選択します。
同様に、Link_2にジョグ情報を追加します。
[プロパティ]ウィンドウの、[DOF]は[TY]です。
操作盤のボタンを設定する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

操作盤を作ってみよう(3/3)

オリジナルの操作盤を作る方法（押下時にシグナルを制御するPythonスクリプト）
https://youtu.be/t152EsmB69Q
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_115_p3.zip

操作盤を作成する方法について説明します。
本動画では、ボタンをクリックした時、画面表示を切り替え、事前に用意されたモデルに移動指令を出します。
本動画は、操作盤のボタンを設定する方法の続きから説明します。
ボタンの設定が完了しているファイル[Operation Panel2_after.vcmx]が必要です。
ボタンの操作状況を、事前に用意されたモデルへ通知するため、シグナルを追加します。
操作盤を選択します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[ブール型]を選択します。
ブール型シグナルは、オンオフを通知できます。
[プロパティ]ウィンドウで、名前をStartPBに変更します。
同様に、もう1つシグナルを追加します。
名前は、StopPBです。
ボタンをクリックした時、画面の文字とシグナルの値を切り替えるため、PythonScriptを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
[コンポーネントグラフ]ウィンドウに、PythonScriptが追加されたことがわかります。
エディタが自動的に開くため、デフォルトで記述されているソースコードを1行目以外削除します。
スタートボタンを操作した時、画面にSTARTと表示し、StartPBをONの状態にします。
パイソンスクリプトを含むコンポーネントの情報を取得するため、comp=getComponent()と記述します。
PB_ON = comp.findBehaviourと記述することで、コンポーネントのビヘイビアを参照できます。
カッコ内にJogInfoと記述し、名前を指定します。
シグナルを参照するため、signal = comp.findBehaviour("StartPB")と記述します。
press = comp.getPropertyと記述することで、コンポーネントのプロパティを参照できます。
カッコ内にPressStartと記述し、名前を指定します。
画面に表示する文字を切り替えるため、change = comp.getProperty("Change")と記述します。
def OnRun():と記述することで、シミュレーション開始時にプログラムを実行できます。
操作盤の初期状態を定義するため、change.Value = 1と記述します。
ボタンの初期状態を定義するため、press.Value = Falseと記述します。
ボタンをクリックした時に実行する関数を作成します。
def OnRun():と、インデントを合わせます。
シフトキーとタブキーを同時に押すことで、インデントを上げることができます。
インデントを1つ上げます。
「def 関数名 (引数の変数名):」と記述することで、関数を作成できます。
今回は、関数名をOnPress、引数の変数名をJogInfo、cursor_action、arg_listとします。
JogInfoは、ジョグ情報です。
cursor_actionは、マウス操作の状況です。
カーソルをオブジェクト上に合わせると、値が0になります。
クリック、またはドラッグすると、値は1、オブジェクト上からカーソルを外すと、値は2です。
arg_listは、マウス操作に関する情報のリストです。
if cursor_action == 1と記述し、スタートボタンをクリック、またはドラッグした場合、プログラムを実行します。
and arg_list[0] == 1:と追加し、マウスボタンを押した時のみ、プログラムを実行します。
スタートボタンをクリック、またはドラッグした場合、画面にSTARTと表示します。
change.Value = 2と記述することで、スイッチの子階層にある2番目のフィーチャを有効化できます。
ボタンを押し込むため、press.Value = Trueと記述します。
StartPBをONの状態にするため、signal.signal(True)と記述します。
インデントを1つ上げます。
else:と記述し、スタートボタンをクリック、またはドラッグしていない場合、プログラムを実行します。
ボタンをもとの位置に戻すため、press.Value = Falseと記述します。
StartPBをOFFの状態にするため、signal.signal(False)と記述します。
ボタンをクリックした時、関数OnPressを実行します。
グローバル変数とインデントを合わせるため、シフトキーとタブキーを2回押します。
PB_ON.OnInteract = OnPressと記述することで、ボタンをクリックした時、関数OnPressを実行できます。
Pythonスクリプトエディタ左上の[コンパイル]をクリックします。
ストップボタンをクリックした時、画面にSTOPと表示し、StopPBをONの状態にするため、PythonScriptを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
[コンポーネントグラフ]ウィンドウに、PythonScript_2が追加されたことがわかります。
PythonScript_2の内容は、PythonScriptと類似しているため、コピーします。
PythonScriptの記述をすべて選択し、コピーします。
PythonScript_2の記述をすべて選択し、貼り付けます。
PythonScript_2の記述を修正します。
4行目で、参照するビヘイビアの名前をJogInfo_2に変更します。
5行目で、参照するシグナルの名前をStopPBに変更します。
6行目で、参照するプロパティの名前をPressStopに変更します。
ストップボタンをクリック、またはドラッグした時、画面にSTOPと表示します。
15行目を、change.Value = 1に変更します。
[コンパイル]をクリックします。
操作盤のボタン操作と、モデルの動作を連動させるため、シグナルを接続します。
[接続]グループから[シグナル]を選択します。
操作盤を選択することで、シグナルエディタを表示できます。
[Operation Panel]で[StartPB]を選択し、[Rail]の[StartSignal]右側の丸をクリックすることで、接続できます。
同様に、[Operation Panel]の[StopPB]と、[Rail]の[StopSignal]を接続します。
画面右下の[閉じる]をクリックします。
動作を確認するため、シミュレーションを実行します。
[マニピュレーション]グループで、[インタラクティブ]を選択します。
スタートボタンをクリックします。
ボタンが押されて、操作盤の画面にSTARTと表示され、ブロックが移動を開始することがわかります。
ストップボタンをクリックします。
ボタンが押されて、操作盤の画面にSTOPと表示され、ブロックが初期位置に戻ると、移動を終了することがわかります。
シミュレーションをリセットします。
操作盤を作成する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

装置が製品を搬送するタイミングを制御してみよう

装置が製品を搬送するタイミングを、パイソンスクリプト（Python）を使用して、センサー、シグナル、条件分岐で制御する方法
https://youtu.be/K2Qmot3txwA
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_065.zip

条件分岐、トリガー、またはシグナルを使用して、製品を運ぶ方法を説明します。
動画内で使用するGeminiのファイルをダウンロードします。
ファイル名は、[ConditionsAndSignalsStart.vcmx]です。
ファイルを開くと、Geminiにコンポーネントが表示されます。
[モデリング]タブを開きます。
3Dワールドのコンポーネントを選択します。
[コンポーネントグラフ]ウィンドウのノードツリーをすべて展開するため、「＋」を選択します。
シミュレーションを実行すると、白い板がパスに沿って、青いブロックの上に生成されます。
シミュレーションをリセットします。
[コンポーネントグラフ]ウィンドウを確認すると、Link1に白い板を動かすためのパスが設定されています。
ServoPathを選択します。
[プロパティ]ウィンドウの[パス]を確認すると、ServoBegin、ServoMiddle、ServoEndが設定されています。
3Dワールド上の青いブロックに設定されている3つのフレームを通るパスに沿って、白い板が移動していることがわかります。
ComponentPathSensorは、白い板を検知するためのセンサーです。
[プロパティ]ウィンドウの[フレーム]には、[ServoMiddle]が設定されています。
[コンポーネントシグナル]には、ServoSensorSignalが設定されています。
白い板がServoMiddleを通った時に、ServoSensorSignalがトリガーします。
ServoPathの[プロパティ]ウィンドウの[TransitionSignal]は、コンポーネントがコンテナに入るときと出るときに、シグナルを発信するために使用する信号を定義します。
[TransitionSignal]には、ComponentEnteringSignalが設定されています。
白い板がServoPathに入るときと出るときに、ComponentEnteringSignalが移動を検知します。
白い板がセンサーを通った時に、青いブロックが板を端まで運ぶ動作を追加します。
[コンポーネントグラフ]ウィンドウのルートノードを選択します。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
comp = getComponent()と記述し、Pythonスクリプトを設定しているコンポーネントを取得します。
servo = comp.findBehaviour("ServoController")と記述し、ServoControllerのビヘイビアを取得します。
servo_path = comp.findBehaviour("ServoPath")と記述し、ServoPathのビヘイビアを取得します。
servo_sensor_signal = comp.findBehaviour("ServoSensorSignal")と記述し、ServoSensorSignalのビヘイビアを取得します。
part_entering_signal = comp.findBehaviour("ComponentEnteringSignal")と記述し、ComponentEnteringSignalのビヘイビアを取得します。
シミュレーションを実行したときの動作を設定します。
if文で条件分岐を使用し、センサーが白い板を検知した場合、青いブロックを600mm移動させ、それ以外はメッセージを表示します。
if servo_sensor_signal.Value != None:と記述し、センサーがNoneでない場合、つまり、センサーが白い板を検知した場合の処理を記述します。
servo.moveJointと記述し、青いブロックの動作範囲を設定します。
サーボコントローラを割り当てたLinkの番号を指定します。
Linkは、Link1の1つしかないため、0番目にします。
青いブロックは600mm動かすため、600と記述します。
else:と記述し、センサーに白い板がない場合の処理を記述します。
print "センサーにコンポーネントはありません"と記述し、メッセージを表示します。
コンパイルボタンをクリックします。
シミュレーションを実行すると、青いブロックは移動しません。
これは、白い板をセンサーが検知する前にif文の処理が開始し、Falseになってしまうためです。
シミュレーションをリセットします。
センサーが白い板を検知するまで、処理を待機する記述に変更します。
if文を削除し、conditionに置き換えます。
conditionを使用すると、servo_sensor_signal.ValueがTrueを返すまで、待機することができます。
servo_sensor_signal.Valueは、def文の関数で定義する必要がありますが、lambdaを記述することで、関数を省略できます。
elseを削除し、print関数をconditionの下に移動します。
コンパイルボタンをクリックします。
シミュレーションを実行すると、青いブロックは移動しません。
これは、センサーの信号の値を取得しておらず、センサーが白い板を検知したか分からないためです。
シミュレーションをリセットします。
センサーの信号の値を取得します。
servo_sensor_signal.signal(comp)と記述し、センサーの信号の値をシグナル化し、センサーの状態を取得します。
コンポーネント内のセンサーの状態を取得するため、引数はcompとします。
コンパイルボタンをクリックします。
シミュレーションを実行すると、青いブロックは移動しますが、白い板がセンサーを通る前に移動します。
シミュレーションをリセットします。
白い板をセンサーが検知した場合、青いブロックが移動するように設定します。
conditionを削除し、triggerConditionに置き換えます。
triggerConditionを使用すると、信号や動作をトリガーとして、処理が実行されます。
コンパイルボタンをクリックします。
シミュレーションを実行すると、青いブロックが移動しません。
これは、スクリプト上にトリガーとなる信号などがないためです。
シミュレーションをリセットします。
トリガーを条件にスクリプトを処理したい場合は、Python Scriptのビヘイビアに接続された信号を使用することができます。
PythonScriptのダイアログを閉じます。
[コンポーネントグラフ]ウィンドウで、[ComponentEnteringSignal]を選択します。
[プロパティ]ウィンドウの[接続]をクリックします。
プラスボタンが表示されるため、クリックすると、[Add 'Connections' items]ダイアログが表示されます。
[Python Script]を選択すると、[接続]に追加されたことがわかります。
[Add 'Connections' items]ダイアログを閉じます。
シミュレーションを実行します。
白い板が青いブロックに到着した後、青いブロックが移動しますが、白い板がセンターを通る前に、青いブロックが移動してしまいます。
ComponentEnteringSignalは、白い板がServoPathに入るときに検知するため、センターを通る前に青いブロックが移動します。
シミュレーションをリセットします。
青いブロックの中心位置にあるセンサーの信号をトリガーするように接続先を設定します。
[コンポーネントグラフ]ウィンドウで、[ServoSensorSignal]を選択します。
[プロパティ]ウィンドウの[接続]をクリックします。
プラスボタンが表示されるため、クリックすると、[Add 'Connections' items]ダイアログが表示されます。
[Python Script]を選択すると、[接続]に追加されたことがわかります。
[Add 'Connections' items]ダイアログを閉じます。
[コンポーネントグラフ]ウィンドウで、PythonScriptを開きます。
ServoSensorSignalをトリガーとして動作させているため、センサー信号の値を取得するservo_sensor_signal.signalをコメントアウトします。
1行ずつコメントアウトする場合は、＃を使用します。
コンパイルボタンをクリックします。
シミュレーションを実行すると、センサーが白い板を検知してから、青いブロックが移動します。
シミュレーションをリセットします。
trrigerConditionを削除し、conditionに置き換え、()内でgetTriggerを使用することで、同様の処理ができます。
複数の信号に接続されているスクリプトで、必要なトリガーだけを指定する必要がある場合に便利です。
コンパイルボタンをクリックします。
シミュレーションを実行すると、先ほどと同様に、センサーが白い板を検知してから、青いブロックが移動します。
また、青いブロックが端まで移動している途中で、白い板も動いていることがわかります。
シミュレーションをリセットします。
青いブロックが端まで移動している途中で、白い板の動作を止めるように設定します。
def OnRun内の記述を削除し、passを追加します。
コンパイルボタンをクリックすると、OnRun内のイベントの履歴がクリアされます。
passを削除します。
while True:と記述し、ループ処理します。
triggerCondition(lambda:getTrigger()==servo_sensor_signal)と記述し、servo_sensor_signalがトリガーされるまで待機します。
servo_path.Enabled = Falseと記述し、白い板がセンサーに到着した後、ServoPathをFalseにし、停止させます。
servo.moveJoint(0,600.0)と記述し、青いブロックを端まで移動します。
servo_path.Enabled = Trueと記述し、青いブロックが端まで移動した後、ServoPathをTrueにし、白い板を移動させます。
condition(lambda:part_entering_signal.Value==False)と記述し、白い板が青いブロックを離れるまで待機します。
servo_path.Enabled = Falseと記述し、白い板が青いブロックを離れた後、ServoPathをFalseにし、停止させます。
servo.moveJoint(0,0.0)と記述し、青いブロックをスタートの位置に戻します。
servo_path.Enabled = Trueと記述し、再度白い板を移動させます。
コンパイルボタンをクリックします。
シミュレーションを実行すると、青いブロックが白い板を繰り返し運んでいることがわかります。
また、ServoPathのOutputはどこにも接続されていないため、白い板が青いブロックを離れると消えています。
シミュレーションをリセットします。
conditionやtriggerConditionメソッドを使用する代わりに、シグナルを使用することで、同様の処理ができます。
OnRun内のtriggerConditionとconditionを削除します。
OnSignalのpassを削除します。
OnSignalで動作を開始するタイミングを制御し、OnRunで停止のタイミングを制御します。
OnRunにsuspendRun()と記述し、白い板がセンサーを検知するまで、OnRun関数の実行を停止します。
OnSignalにif signal==sevo_sensor_signal:if signal.Value != None:と記述し、センサーがNoneでない場合、つまり、白い板がセンサーを検知した場合の処理を実行します。
resumeRun()と記述し、OnRun関数の実行を開始します。
servo_path_Enabled=Falseからservo_path_Enabled=Trueで、青いブロックを端まで移動します。
suspendRunと記述し、白い板が青いブロックを離れるまで、OnRun関数の実行を停止します。
elif signal==part_entering_signal:if signal.Value==False:と記述し、白い板が青いブロックを離れた場合の処理を実行します。
resumeRun()と記述し、OnRun関数の実行を開始します。
servo_path_Enabled=Falseからservo_path_Enabled=Trueで、青いブロックをスタートの位置に戻します。
コンパイルボタンをクリックします。
シミュレーションを実行すると、先ほどと同様に、青いブロックが白い板を繰り返し運んでいることがわかります。
シミュレーションをリセットします。
条件分岐、トリガー、またはシグナルを使用して、製品を運ぶ方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

装置シミュレーションでワークを削除しよう

シミュレーション中に生成した製品を途中で削除する方法（Product Bin (Physics)、パイソンスクリプト（Python））
https://youtu.be/I_PkXxELko0
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_132.zip

装置シミュレーションで、シミュレーション中にワークを削除する方法について説明します。
付属ファイル「WorkDelete_before.vcmx」を開きます。
ワーク2つ、搬送先のテーブル、フィーダー、ロボットが配置されていることを確認します。
シミュレーションを実行します。
フィーダーからワークが生成され、ロボットがワークを搬送します。
シミュレーションをリセットします。
ワークを削除するモデルを、eカタログから配置します。
[タイプ別モデル]を展開し、[Physics]をクリックします。
[Product Bin(Physics)]をダブルクリック、またはドラッグ＆ドロップし、3Dワールドに配置します。
Product Bin(Physics)をテーブル上に移動させます。
Product Bin(Physics)を選択した状態で、[ツール]グループの[スナップ]を選択します。
[スナップ]は、選択したものを、コンポーネントのクリックした位置に移動させることができます。
テーブルの中心をクリックします。
[Product Bin(Physics)]を、ワークを削除するモードに切り替えます。
[コンポーネントプロパティ]ウィンドウで、[Mode]をSink、[Interval]を5に変更します。
シミュレーションを実行します。
ロボットがワークを搬送し、シミュレーション時間が5秒に達すると、ワークは削除されます。
シミュレーション開始から、[Interval]の周期で、ワークを削除できます。
ワーク搬送後、ワークを削除するまでの時間を指定することはできません。
ワーク搬送後、指定した時間待機し、ワークを削除する方法を説明します。
シミュレーションをリセットし、[Product Bin(Physics)]を削除します。
搬送先で、ワークを検出し、5秒待機後、ワークを削除するため、テーブルに設定を追加します。
テーブルを選択し、[モデリング]タブを開きます。
削除するワークを検出するため、センサーを追加する必要があります。
センサーの位置を設定します。
[ジオメトリ]グループの[フィーチャ]を展開し、[その他]から[フレーム]を選択します。
フレームは、3Dワールド上で、位置と方向を定義する基準点です。
3Dワールドに、フレームが表示されない場合、3Dワールドツールバーの[フレームタイプ]を展開し、フレームにチェックを付けます。
アイコンが透明な場合、[フレームタイプ]は無効であるため、アイコンをクリックし、有効にする必要があります。
3Dワールドに、フレームを表示することができます。
フレームを移動させます。
[フィーチャプロパティ]ウィンドウで、座標[Y]を300、[Z]を500、[Ry]を90に変更します。
ワークを検出するため、センサーを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[センサー]から[レイキャスト]を選択します。
レイキャストセンサーは、定義したフレームの位置から光線を照射し、光線と交差したコンポーネントを検出できます。
センサーの位置を、フレームを選択して、定義します。
[プロパティ]ウィンドウの[フレーム]を選択することで、選択したフレームの+Z軸方向に光線を照射できます。
表示する光線の長さと、ワークを検出する範囲を設定します。
[最大範囲]は、センサーと、検出したコンポーネントとの距離を測定できる範囲です。
[シグナル範囲]で、実数型シグナルを定義することで、距離を出力できます。
今回、距離は測定しませんが、3Dワールドに表示される光線の長さを変更するため、[最大範囲]を200に変更します。
[検出しきい値]は、コンポーネントを検出できる範囲です。
[検出しきい値]を200に変更します。
光線を非表示にする時は、[光線表示]のチェックを外し、光線を表示する時は、[光線表示]にチェックを付けます。
今回は、[光線表示]にチェックを付けます。
[コンポーネントシグナル]は、検出したコンポーネントを、値として格納するシグナルを定義できます。
センサーで検出したコンポーネントを取得するため、シグナルを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[コンポーネント]を選択します。
コンポーネントシグナルは、コンポーネントを値として送受信できます。
[コンポーネントグラフ]ウィンドウで、RaycastSensorを選択します。
[プロパティ]ウィンドウの[コンポーネントシグナル]で、ComponentSignalを選択します。
ワークを削除するため、PythonScriptを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
Pythonスクリプトエディタが自動的に開きます。
デフォルトで記述されているソースコードを、1行目以外削除します。
パイソンスクリプトを含むコンポーネントの情報を取得するため、comp = getComponent()と記述します。
signal = comp.findBehaviourと記述することで、コンポーネントのビヘイビアを参照できます。
カッコ内にComponentSignalと記述し、名前が一致するビヘイビアを参照します。
def OnRun():と記述することで、シミュレーション開始時にプログラムを実行できます。
while True:と記述し、以下のプログラムをループさせます。
triggerCondition(lambda:getTrigger()==signal)と記述することで、ComponentSignalの値が変化するまで、以下のプログラムを実行せず、待機できます。
ComponentSignalの値に、コンポーネントが格納されたとき、プログラムを実行するため、and signal.Value != Noneと追記します。
センサーで検出したコンポーネントを、ワークとして定義するため、work = signal.Valueと記述します。
センサーがワークを検出した後、5秒待機します。
delay()と記述することで、指定した時間、プログラムの実行を遅延させることができます。
カッコ内に5と入力し、5秒、プログラムの実行を遅延させます。
ワークを削除するため、work.delete()と記述します。
Pythonスクリプトエディタ左上の[コンパイル]をクリックします。
先程、PythonScriptに記述したtriggerConditionで、ComponentSignalをトリガーとして使用するため、接続します。
[コンポーネントグラフ]ウィンドウで、ComponentSignalを選択します。
[プロパティ]ウィンドウで、[接続]をクリックすることで、プラスアイコンが表示されます。
プラスアイコンをクリックし、表示される[Add Connections items]ウィンドウで、PythonScriptを選択します。
[Add Connections items]ウィンドウを閉じます。
シミュレーションを実行します。
ロボットがワークを搬送し、5秒後、ワークが削除されたことがわかります。
PythonScriptのdeleteを使用する場合、注意が必要です。
削除したコンポーネントは、シミュレーションのリセットボタンや、CtrlキーとZキーを使用しても元に戻すことができません。
シミュレーションをリセットします。
[ホーム]タブを開きます。
FeederとWorkAの位置を入れ替えるため、Feederを選択します。
[コンポーネントプロパティ]ウィンドウで、座標[Y]に1000と入力します。
WorkAを選択します。
[コンポーネントプロパティ]ウィンドウで、座標[Y]に0、[Z]に600と入力します。
シミュレーションを実行します。
WorkAが削除されたことがわかります。
シミュレーションのリセットボタン、またはCtrlキーとZキーを押します。
WorkAをもとに戻すことはできません。
コンポーネントを完全に削除しない場合、コンポーネントを非表示にし、削除する様子のみ再現する方法があります。
WorkBを選択します。
[コンポーネントプロパティ]ウィンドウで、座標[X]、[Y]に0、[Z]に600と入力します。
Tableを選択し、[モデリング]タブを開きます。
[コンポーネントグラフ]ウィンドウで、PythonScriptをダブルクリックします。
work.delete()を、work.Visible = Falseに変更します。
コンパイルをクリックします。
シミュレーションを実行します。
ワークが削除されたように見えますが、[ホーム]タブの[セルグラフ]ウィンドウを確認すると、WorkBが非表示であることがわかります。
装置シミュレーションで、シミュレーション中にワークを削除する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

装置シミュレーション用コンベアを作ってみよう(1/3)

フィーダーを使わずに、複数種類のワークを生成する方法
https://youtu.be/8GCep1ZqL_8
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_050_p1.zip

複数種類のワークを生成してコンベアに流す方法について説明します。
最初は、1種類のワークを生成する方法を説明します。
CADファイルをインポートします。
[ホーム]タブを選択し、[インポート]グループの[ジオメトリ]をクリックすることで、CADファイルをインポートすることができます。
[Conveyor.step]を選択し、[開く]をクリックします。
[モデルをインポート]ウィンドウでは、インポート時のプロパティを設定することができます。
[構造]は、単一のモデルをインポートする場合、[フィーチャ]か[ノード]を選択し、レイアウトをインポートする場合、[コンポーネント]を選択します。
コンベアは、単一のモデルのため、[フィーチャ]を選択します。
3Dワールドに表示されるモデルは、多数の三角形で構成されており、[テッセレーションの品質]は、三角形の個数を設定することができます。
データ量の多いモデルの場合、低品質にすることで、データ量を削減することができます。
データ量の多いモデルではないため、[中位品質]に設定します。
[含める]では、インポートするとき、ジオメトリに含む要素を設定することができます。
[マークアップ]と[マテリアル]と[テクスチャー]を選択します。
[マテリアル作成ルール]では、マテリアルライブラリを作成するためのルールを設定することができます。
[常にライブラリから最も近似のものを使用します]を選択します。
[フィーチャツリー]は、フィーチャツリーの作成方法を、設定することができます。
[完全]は、CADファイルの階層構造をベースにし、すべてのジオメトリをトランスフォームフィーチャに入れ、フィーチャツリーを作成します。
[最適化]は、CADファイルの階層構造をそのまま使用し、[最小化]は、ジオメトリを1つにまとめることができます。
[最適化]を選択します。
[ジオメトリを整理]では、ジオメトリセットを作成するルールを設定することができます。
面ごとにジオメトリセットを作成する場合、[面による]を、マテリアルごとの場合、[マテリアルによる]を選択します。
ジオメトリセットを1つにまとめる場合、[折りたたみ]を、曲線のジオメトリセットを作成する場合、[数学的データ]を選択します。
今回は[折りたたみ]を選択します。
[上軸]は、ジオメトリの上面と底面を整列させる軸を設定することができます。
[上軸]で[+Z]を選択し、[インポート]をクリックします。
コンベアのCADファイルをインポートすることができます。
同様に、ワークAとワークBのCADファイルもインポートします。
Geminiでオリジナルのワークを取り扱う場合、ワークを別ファイルから読み込む必要があります。
ワークとして使用するコンポーネントを、別ファイルに保存します。
ワークAを選択して、[モデリング]タブを開きます。
[コンポーネント]グループの[名前を付けて保存]をクリックすることで、コンポーネントを別ファイルに保存することができます。
画面右下の[名前を付けて保存]をクリックし、任意の場所に保存します。
同様に、ワークBを別ファイルに保存します。
3DワールドでワークBをダブルクリックすることで、コンポーネントを選択することができます。
[コンポーネント]グループの[名前を付けて保存]をクリックし、画面右下の[名前を付けて保存]をクリックします。
ワークBも任意の場所に保存します。
シミュレーション中に、ワークを生成するため、クリエイターを追加します。
コンベアを選択し、[動作設定]グループの[ビヘイビア]を展開します。
[マテリアルフロー]の中から[コンポーネントクリエイター]を選択します。
クリエイターは、シミュレーション中に、新しいコンポーネントを生成することができます。
クリエイターに、生成するワークを設定します。
[プロパティ]ウィンドウの[パーツ]の右隣のアイコンをクリックすることで、別ファイルに保存したワークを設定することができます。
選択するファイルは、[Box_A.vcmx]です。
同様に、ワークBを生成するクリエイターを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[マテリアルフロー]の中から[コンポーネントクリエイター]を選択します。
[プロパティ]ウィンドウの[パーツ]で選択するファイルは、[Box_B.vcmx]です。
生成したワークを表示するためには、どこかに格納する必要があります。
ワークを格納するため、コンテナを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[マテリアルフロー]の中から[コンポーネントコンテナ]を選択します。
コンテナは、コンポーネントに別のコンポーネントを格納することができます。
コンテナやパスに格納されていない場合、クリエイターで生成したコンポーネントは、表示することができません。
シミュレーションを実行します。
ワークを生成していますが、コンテナに格納されていないため、表示されません。
クリエイターで生成したワークを出力し、コンテナに格納するため、2つを接続します。
[コンポーネントグラフ]ウィンドウで、ComponentCreatorを展開することで、OutputとInputという名前のコネクターが表示されます。
Outputを選択し、[プロパティ]ウィンドウの[接続]でComponentContainerを、[ポート]でInputを選択します。
[接続]で、コネクターを持っている別のビヘイビアを定義し、[ポート]で接続するコネクターを定義することができます。
ComponentContainerのInputには、自動的に接続先が設定されます。
シミュレーションを実行します。
ワークが表示されます。
コンテナに格納する位置を設定していないため、ワークはコンベアの原点に表示されます。
ワークを格納する位置を設定します。
[ジオメトリ]グループの[フィーチャ]を展開し、[その他]の中から[フレーム]を選択します。
フレームは、3Dワールド上で、位置と方向を定義する基準点です。
3Dワールドに、フレームが表示されない場合、3Dワールドツールバーの[フレームタイプ]を開き、[フレーム]にチェックを付けます。
3Dワールドに、フレームを表示することができます。
フレームのピンク色の丸をドラッグして、移動します。
フレームの位置にワークの原点がくるため、ワークがコンベアをはみ出ないように、X軸方向に100mm移動します。
コンテナにワークを格納する位置を設定するため、[コンポーネントグラフ]ウィンドウでComponentContainerを選択します。
[プロパティ]ウィンドウの[位置]をクリックし、[フレーム]を選択することで、フレームの位置でワークを格納することができます。
シミュレーションを実行します。
ワークがコンベア上に表示されることがわかります。
ワークが1つ生成され、その場で静止しているように見えますが、ワークは1秒ごとに1個ずつ増加しています。
ワークを生成する個数を変更するため、[コンポーネントグラフ]ウィンドウでComponentCreatorを選択します。
[プロパティ]ウィンドウの[リミット]を設定することで、ワークを生成できる最大個数を変更することができます。
[リミット]を5に設定します。
ワークを格納する個数を変更するときは、コンテナの設定を変更します。
[コンポーネントグラフ]ウィンドウで、ComponentContainerを選択します。
[プロパティ]ウィンドウの[キャパシティー]を設定することで、ワークを格納できる最大個数を変更することができます。
[キャパシティー]を5に設定します。
シミュレーションを実行しますが、表示のされ方に変更点はありません。
次に、1種類のワークをコンベア上に流す方法を説明します。
コンベアに流す開始位置と、終了位置を定義するため、フレームを設定します。
ワークを生成する位置を定義しているフレームの名前を、Startに変更します。
[ジオメトリ]グループの[フィーチャ]を展開して[その他]の中から[フレーム]を選択することで、新しいフレームを追加します。
フレームの名前をEndに変更し、Startの位置からX軸方向に+1800mm移動します。
ワークをコンベア上に流すため、パスを追加します。
[動作設定]グループの[ビヘイビア]を展開します。
[マテリアルフロー]のパスには、ワンウェイパスとツーウェイパスの2種類あります。
ワンウェイパスは指定した一方向に、ツーウェイパスは指定した一方向とその逆方向に、ワークを移動させることができます。
今回は、ワンウェイパスを使用するため、[マテリアルフロー]から[ワンウェイパス]を選択します。
パスにワークを流す順番を定義します。
[プロパティ]ウィンドウの[パス]をクリックして表示されるプラスアイコンをクリックします。
[Add Path items]ウィンドウで、ワークを流す順にStart、Endと選択します。
パスの起動を制御するため、シグナルを追加します。
オンオフを送受信するシグナルを、ブール型シグナルといいます。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]の[ブール型]を選択します。
名前を[PathSignal]に変更します。
パスを制御するため、接続の設定をする必要があります。
[プロパティ]ウィンドウの[接続]で、OneWayPathを選択します。
コンテナに格納する位置を、StartからEndに変更します。
生成したワークを、クリエイターからパスへ、パスからコンテナへ格納することで、コンベア上に流すことができます。
コネクターを接続します。
OneWayPathのOutputを選択し、[接続]でComponentContainerを、[ポート]でInputを選択します。
ComponentContainerのInputを選択すると、自動的に接続されています。
OneWayPathのInputを選択し、[接続]でComponentCreatorを、[ポート]でOutputを選択します。
ComponentCreatorのOutputを選択すると、自動的に接続されています。
パスを流れ終わったワークを、コンベア上に並べるための設定をします。
OneWayPathのOutputを選択し、[プロパティ]ウィンドウの[Physical]にチェックをつけます。
[Physical]にチェックをつけることで、ワークはコンテナに格納されませんが、ワークがパスから出力されることを防ぎます。
パスはデフォルトで、パス内のワークが隣接できる設定のため、コンベア上にワークを並べることができます。
シミュレーションを実行します。
ワークを生成し、コンベア上を流れました。
次に、複数種類のワークを生成する方法を説明します。
ワークを生成するタイミングを指示するため、ブール型シグナルを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[シグナル]から[ブール型]を選択します。
パイソンスクリプトでワークを生成するタイミングを制御するため、ComponentCreatorとComponentCreator_2のワークを生成する間隔と、生成するワークの最大個数を0にします。
パイソンスクリプトを追加し、2種類のワークをランダムに生成するプログラムを記述します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
エディタが自動的に開くため、デフォルトで記述されているソースコードを1行目以外削除します。
ランダムな確率でワークを生成するため、ランダム関数をインポートします。
2行目に、import randomと記述します。
パイソンスクリプトを含むコンポーネントの情報を取得するため、comp = getComponent()と記述します。
signal=comp.findBehaviourと記述することで、コンポーネントのビヘイビアを参照することができます。
カッコ内にBooleanSignalと記述し、名前を指定します。
パスを参照するため、path=comp.findBehaviour("OneWayPath")と記述します。
同様に、ビヘイビアの2つのクリエイターを参照します。
変数名はそれぞれ、creatorと、creator2です。
パイソンスクリプトで、コネクターを接続するため、コネクターの変数を定義します。
creatorのOutputの情報を取得するため、creator_output=creator.getConnector(0)と記述します。
カッコ内でコネクターのインデックスを指定することができ、クリエイターの場合、0がOutput、1がInputです。
同様に、creator2のOutputの情報を取得するため、creator2_ouput=creator2.getConnector(0)と記述します。
pathのInputの情報を取得するため、path_input=path.getConnector(0)と記述します。
クリエイターとは異なり、パスは、0がInput、1がOutputです。
def OnRun():と記述することで、シミュレーションの開始時にプログラムを実行することができます。
シミュレーション開始と同時に、コンベアにワークが流れることを防ぐため、シミュレーション開始時にパスをオフにします。
path.Enabled = Falseと記述することで、PathSignalがオンになるまでパスはオフの状態です。
while True:と記述し、以下のプログラムをループさせます。
triggerCondition(lambda:getTrigger()==signal)と記述することで、signalのオンオフが切り替わるまで、以下のプログラムを実行せず、待機することができます。
signalがTrueの場合、2種類のワークをランダムに生成します。
整数の乱数を生成するため、number=random.randint()と記述します。
生成する乱数の範囲を、1から10に設定します。
乱数が5以下の場合、creatorとpathを接続するため、creator_output.connect(path_input)と記述します。
creator.create()と記述することで、ワークAを生成することができます。
乱数が5より大きく、10以下の場合、creator2とpathを接続するため、creator2_output.connect(path_input)と記述します。
creator2.create()と記述することで、ワークBを生成することができます。
エディタ左上のコンパイルをクリックします。
先程パイソンスクリプトに記述したtriggerConditionでBooleanSignalをトリガーとして使用するため、接続します。
[コンポーネントグラフ]ウィンドウのBooleanSignalを選択し、[接続]でPythonScriptを選択します。
シミュレーションを実行します。
[接続]グループの[シグナル]をクリックし、コンベアを選択することで、シグナルエディタを表示することができます。
PathSIgnalをオンにし、BooleanSignalをオンにすることで、ワークを1つ生成しました。
BooleanSignalのオンとオフを切り替えることで、2種類のワークをランダムに生成していることがわかります。
複数種類のワークを生成し、コンベアに流す方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

装置シミュレーション用コンベアを作ってみよう(2/3)

コンベア上の製品の挙動（前進、後退、一時停止など）を制御する方法
https://youtu.be/chrLyyAt_Mk
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_050_p2.zip

コンベア上を流れるワークを制御する方法について説明します。
まず、シミュレーション中にワークの進行方向を切り替える方法を説明します。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]からOneWayPathを選択し、削除します。
右クリックしてメニューを開き、[削除]を選択します。
ワークを、指定した一方向と、その逆方向の、どちらにも移動可能にするため、ツーウェイパスを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[マテリアルフロー]から[ツーウェイパス]を選択することで、追加することができます。
パスにワークを流す順番を、フレームを選択して、定義します。
[プロパティ]ウィンドウの[パス]をクリックし、[Add Path items]ウィンドウで、Start、Endの順に選択します。
シグナルでパスの起動を制御するため、接続の設定をします。
PathSignalをクリックし、[プロパティ]ウィンドウの[接続]でTwoWayPathを選択します。
クリエイターからパス、パスからコンテナにワークを流すため、接続します。
パスとコンテナのコネクターを接続します。
TwoWayPathのOutputを選択し、[プロパティ]ウィンドウの[接続]でComponentContainerを、[ポート]でInputを選択します。
ワークがパスを通ってコンテナに流れた後、コンベア上に並べるための設定をします。
[プロパティ]ウィンドウの[Physical]にチェックをつけます。
ComponentContainerのInputには、自動的に接続先が設定されます。
クリエイターとパスを接続するため、ワークを生成するパイソンスクリプトを編集します。
[コンポーネントグラフ]ウィンドウのPythonScriptを開きます。
変数pathは、OneWayPathを参照していますが、TwoWayPathに変更します。
コンパイルをクリックします。
シミュレーションを実行します。
[接続]グループの[シグナル]をクリックし、コンベアを選択します。
シグナルエディタのPathSignalを、クリックしてオンにします。
BooleanSignalをオンにすると、ワークを生成し、コンベアを流れることがわかります。
[コンポーネントプロパティ]ウィンドウで[TwoWayPath]タブをクリックします。
[方向]を変更することで、進行方向を変更することができます。
[バックワード]に設定すると、ワークの進行方向が変化することがわかります。
シミュレーションをリセットし、[シグナル]をクリックしてシグナルエディタを閉じます。
進行方向を変更するタイミングを指示するため、プロパティを追加します。
プロパティは、コンポーネントのグローバル変数です。
グローバル変数とは、プログラム内のどこからでも使用できる変数のことです。
プロパティがオンの場合、[方向]を[フォワード]に、プロパティがオフの場合、[バックワード]に設定するため、ブール型プロパティを追加します。
[プロパティ]グループの[プロパティ]を展開し、[ベーシック]から[ブール型]を選択します。
名前を「Forward」に変更します。
プロパティの値を変更した時に、進行方向が変更するように設定するため、パイソンスクリプトを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
エディタが自動的に開くため、デフォルトで記述されているソースコードを1行目以外削除します。
コンポーネントの情報を取得するため、comp=getComponent()と記述します。
パスの詳細設定を変更するため、path=comp.findBehaviour("TwoWayPath")と記述します。
コンポーネントのプロパティを参照するため、forward=comp.getPropertyと記述します。
参照するプロパティの名前は、「Forward」です。
シミュレーション開始時に、プログラムを実行するため、def OnRun():と記述します。
シミュレーション開始時、進行方向がフォワードでない場合、ワークをパスに流すことができません。
Forwardの初期値を設定するため、forward.Value=Trueと記述します。
while True:と記述し、以下のプログラムをループさせます。
while Trueのみでは、瞬時にプログラムが繰り返し実行されるため、処理が追い付かず、シミュレーションが進みません。
ループ中に遅延させることで、処理の時間に猶予を持たせ、シミュレーションを進めることができます。
delayと記述することで、指定した時間、遅延させることができます。
カッコ内に0.1と記述することで、0.1秒遅延させます。
forwardがTrueの場合、パスの[方向]を[フォワード]に設定します。
path.Direction=VC_PATH_FORWARDと記述することで、パスの[方向]を[フォワード]に設定することができます。
forwardがTrueではない場合、パスの[方向]を[バックワード]に設定します。
path.Direction=VC_PATH_BACKWARDと記述することで、パスの[方向]を[バックワード]に設定することができます。
コンパイルをクリックします。
シミュレーションを実行します。
[接続]グループの[シグナル]をクリックし、コンベアを選択してシグナルエディタを表示します。
[コンポーネントプロパティ]ウィンドウの[既定]タブをクリックすることで、Forwardを表示することができます。
シグナルエディタでPathSignalをオンにします。
BooleanSignalをオンにし、ワークを生成します。
Forwardをオフにします。
ワークの進行方向が変化しました。
Forwardを再びオンにします。
ワークの進行方向が元に戻りました。
次に、コンベア上を流れるワークを停止させる方法を説明します。
コンベア上にワークが流れている状態で、PathSignalをオフにします。
パス自体がオフのため、コンベア上を流れるすべてのワークを停止させることができます。
PathSignalを再びオンにします。
ワークは移動を再開します。
シミュレーションをリセットし、[シグナル]をクリックしてシグナルエディタを閉じます。
ワークを特定の位置で停止するため、前半のパス、コンテナ、後半のパスを設定し、コンテナに格納されたワークを停止させます。
パスを前半と後半に分けるため、コンベアの中間地点にフレームを追加します。
[ジオメトリ]グループの[フィーチャ]を展開し、[その他]から[フレーム]を選択します。
名前をMidに変更し、コンベアの中間地点に移動します。
パスにワークを流す順番を、フレームを選択して、定義します。
[コンポーネントグラフ]ウィンドウからTwoWayPathを選択します。
[プロパティ]ウィンドウの[パス]をクリックし、フレームにカーソルを合わせることで、ゴミ箱アイコンが表示され、クリックすることで削除できます。
Endを削除し、Midを追加します。
後半のパスを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[マテリアルフロー]から[ツーウェイパス]を選択します。
ワークが流れる順番をMid、Endに設定します。
コンベアの中間地点にコンテナを設定し、コンテナに格納できる最大個数を変更することで、ワークを停止します。
[コンポーネントグラフ]ウィンドウでComponentContainerを選択します。
[プロパティ]ウィンドウで[位置]をEndからMidに変更します。
[キャパシティー]を変更することで、コンポーネントを格納できる最大個数を設定することができます。
[キャパシティー]を1に変更します。
パスからコンテナにワークを格納するため、TwoWayPathのOutputを選択し、[プロパティ]ウィンドウの[Physical]のチェックを外します。
シミュレーションを実行します。
[接続]グループの[シグナル]をクリックし、コンベアを選択してシグナルエディタを表示します。
PathSignalとBooleanSignalをオンにします。
ワークは停止しましたが、移動を再開する設定をまだしていないため、停止したワークを移動させることはできません。
シミュレーションをリセットし、[シグナル]をクリックしてシグナルエディタを閉じます。
ワークの停止と、移動再開をプロパティで制御します。
[プロパティ]グループの[プロパティ]を展開し、[ベーシック]から[ブール型]を選択します。
名前をStopに変更します。
Stopがオフの場合、ワークをコンテナから後半のパスに流し、Stopがオンの場合、ワークを後半のパスには流さず、前半のパスをオフにします。
[動作設定]グループの[ビヘイビア]を展開し、[その他]から[パイソンスクリプト]を選択します。
エディタが自動的に開くため、デフォルトで記述されているソースコードを1行目以外削除します。
コンポーネントを取得するため、comp=getComponent()と記述します。
comp.findBehaviourと記述し、ビヘイビアからTwoWayPath、TwoWayPath_2、ComponentContainerを参照します。
変数名は、path、path2、contです。
プロパティを参照するため、stop=comp.getProperty("Stop")と記述します。
シミュレーション開始時に、プログラムを実行するため、def OnRun():と記述します。
while True: 、delay(0.1)と記述し、以下のプログラムを繰り返し実行します。
stopがFalseの場合、ワークをコンテナから後半のパスに流します。
PathSignalがオンになるまでワークを流さないため、条件を追加します。
前半のパスかコンテナにワークが格納された場合、後半のパスへワークを流すため、if path.ComponentCount>0 or cont.Component>0:と記述します。
前半のパスをオンにするため、path.Enabled=Trueと記述します。
コンテナの先頭に格納されたワークを取得するため、work=cont.HeadComponentと記述します。
取得したワークを後半のパスに格納するため、path2.grab(work)と記述します。
stopがTrueの場合、コンテナにワークが1つ格納された時点で前半のパスをオフにします。
コンテナにワークが1つ格納された場合プログラムを実行するため、if cont.ComponentCount==1:と記述します。
前半のパスをオフにするため、path.Enabled=Falseと記述します。
コンパイルをクリックします。
シミュレーションを実行します。
[接続]グループの[シグナル]をクリックし、コンベアを選択してシグナルエディタを表示します。
[コンポーネントプロパティ]ウィンドウで、Stopがオフであることを確認します。
PathSignalとBooleanSignalをオンにします。
ワークがコンベア上を流れることがわかります。
Stopをオンにし、ワークを生成します。
ワークはコンベアの中間地点で停止します。
Stopをオフにします。
ワークが移動を再開します。
コンベア上を流れるワークを制御する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

装置シミュレーション用コンベアを作ってみよう(3/3)

コンベア上の製品が流れる先のルート分岐を制御する方法
https://youtu.be/6etgl5h7m2k
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_050_p3.zip

分岐があるコンベアにワークを流し、ルートを変更する方法について説明します。
ワークを停止させるパイソンスクリプトを削除します。
[コンポーネントグラフ]ウィンドウの[ビヘイビア]から、PythonScript_3を選択します。
右クリックしてメニューを開き、[削除]を選択します。
ワークの停止と移動再開を制御するプロパティを削除します。
[コンポーネントグラフ]ウィンドウの[プロパティ]から、Stopを選択します。
右クリックしてメニューを開き、[削除]を選択します。
コンベアの直進するルートをルートA、カーブするルートをルートBとします。
コンベアに新しくルートBを設定するため、フレームを追加します。
[コンポーネントグラフ]ウィンドウのConveyorを選択します。
[ジオメトリ]グループの[フィーチャ]を展開し、[その他]から[フレーム]を選択します。
3Dワールドに、フレームが表示されない場合、3Dワールドツールバーのフレームタイプを開き、フレームにチェックを付けます。
3Dワールドにフレームを表示することができます。
名前をTurnに変更します。
同様に、フレームを2つ追加します。
名前はRouteB_Startと、RouteB_Endです。
Turnを選択して[ツール]グループの[スナップ]を選択することで、Turnを目的の位置に移動させることができます。
3Dワールドで、Midをクリックします。
[フィーチャプロパティ]ウィンドウの座標[X]に+100と入力し、エンターキーを押すことで、現在の座標に100mm加算されます。
RouteB_Startを選択し、[ツール]グループの[スナップ]を選択します。
3Dワールドで、Turnをクリックします。
[フィーチャプロパティ]ウィンドウの座標[Y]に-200と入力し、エンターキーを押します。
RouteB_Endを選択し、[ツール]グループの[スナップ]を選択します。
3Dワールドで、RouteB_Startをクリックします。
[フィーチャプロパティ]ウィンドウの座標[Y]に-900と入力し、エンターキーを押します。
パス上のワークは、フレームの位置と方向に沿って移動します。
フレームの方向を変更することで、移動中のワークの方向を変更することができます。
Turnを選択し、[フィーチャプロパティ]ウィンドウで座標[Rz]を-45に設定します。
RouteB_StartとRouteB_Endの座標[Rz]を-90に設定します。
ワークは、MidからRouteB_Startまでの移動中、-90度回転します。
ルートBを設定するため、パスを追加します。
[動作設定]グループの[ビヘイビア]を展開し、[マテリアルフロー]から[ツーウェイパス]を選択します。
パスにワークが流れる順番を、フレームで定義します。
[プロパティ]ウィンドウの[パス]をクリックし、Mid、Turn、RouteB_Start、RouteB_Endの順に選択します。
搬入時のワークの位置と方向を保持する場合、[オフセット保持]にチェックをつけます。
搬入時のワークの位置と方向に関係なく、フレームに沿って移動させる場合、[オフセット保持]のチェックを外します。
今回は、[オフセット保持]にチェックをつけます。
ルートAにワークが流れた場合、コンベア上にワークを並べるための設定をします。
[コンポーネントグラフ]ウィンドウのComponentContainerを選択します。
[プロパティ]ウィンドウの[位置]を、MidからEndに変更します。
ワークをパスからコンテナへ格納するため、コネクターを接続します。
TwoWayPath_2のOutputを選択し、[プロパティ]ウィンドウの[接続]で「ComponentContainer」を、[ポート]で「Input」を選択します。
パスを流れ終わったワークをコンベア上に並べるため、[プロパティ]ウィンドウの[Physical]にチェックをつけます。
ComponentContainerのInputを選択すると、自動的に接続されています。
ルートBにワークが流れた場合、コンベア上にワークを並べるための設定をします。
[動作設定]グループの[ビヘイビア]を展開し、[マテリアルフロー]から[コンポーネントコンテナ]を選択します。
[プロパティ]ウィンドウの[位置]をRouteB_Endに設定します。
ワークをパスからコンテナへ格納するため、コネクターを接続します。
TwoWayPath_3のOutputを選択し、[接続]でComponentContainer_2を、[ポート]でInputを選択します。
パスを流れ終わったワークをコンベア上に並べるため、[プロパティ]ウィンドウの[Physical]にチェックをつけます。
ComponentContainer_2のInputを選択すると、自動的に接続されています。
コンベアに条件を設定し、A・Bにルートを分岐して流れるようにします。
条件をプルダウンで選択できるようにします。
今回は、プロパティの値を参照し、ルートを変更します。
ワークを流すルートは2つのため、ブール型プロパティを追加し、値がFalseの場合はルートAに、Trueの場合はルートBにワークを流します。
[プロパティ]グループの[プロパティ]を展開し、[ベーシック]から[ブール型]を選択します。
名前をRouteに変更します。
ルートを変更するため、ルーティングルールを追加します。
ルーティングルールは、条件の結果に応じて、異なるパスやコンテナに、コンポーネントを転送することができます。
[動作設定]グループの[ビヘイビア]を展開し、[マテリアルフロー]から[ルーティングルール]を選択します。
[プロパティ]ウィンドウの[ルールコンポーネント]は、ルールに使用するパラメーターの場所を定義することができます。
所有者の場合は、ルーティングルールを含むコンポーネント、処理済みの場合は、ルーティングルールを含むコンポーネントと、接続された別のコンポーネントです。
今回は、所有者を選択します。
[タイプ]では、条件の種類を設定します。
環状ルールでは、ルートの順番を設定し、ルートに1つずつコンポーネントを流すことができます。
キャパシティールールは、ルートの順番を設定することで、1つのルートに格納できる個数までワークを流し、次のルートにワークを流します。
固定ルールは、特定のコネクターに入力されたコンポーネントを、特定のコネクターから出力することができます。
割合ルールは、各ルートに、確率を設定し、確率に基づき、ワークを流します。
ブール型表ルール、整数表ルール、実数表ルール、文字列表ルールは、プロパティの値を参照してルートを変更することができます。
プロパティの型と条件の種類を一致させる必要があります。
[トランスポートソリューションルール]は、トランスポートソリューションに基づき、ルートを変更することができます。
トランスポートソリューションルールを使用する場合、[ビヘイビア]の[トランスポートノード]で物を輸送できる位置を設定する必要があります。
1つのトランスポートノードから次のトランスポートノードまでのルートを、トランスポートソリューションといいます。
[製品タイプルール]は、製品タイプに基づき、ルートを変更することができます。
製品タイプは、生成する製品の定義です。
製品の名前やコンポーネントURIを設定することで、生成する製品を定義します。
今回は、[タイプ]をブール型表ルールに設定します。
分岐前のパス、ルートAのパス、ルートBのパスと、ルーティングルールを接続するため、コネクターを追加します。
[プロパティ]ウィンドウの[新規コネクターを追加]をクリックすることで、コネクターを追加できます。
[コンポーネントグラフ]ウィンドウのRoutingRuleを展開すると、ポート1が追加されたことがわかります。
同様に、コネクターを2つ追加します。
ポート1は、ルーティングルールにワークを入力するためのコネクターに設定します。
ポート2とポート3は、ルーティングルールからワークを出力するためのコネクターに設定します。
[プロパティ]ウィンドウの[変数]に名前を入力することで、参照するプロパティを指定することができます。
指定するプロパティは、Routeです。
プロパティの値に基づき、使用するコネクターか、条件を設定することができます。
RouteがFalseの場合はポート2を、RouteがTrueの場合はポート3を使用します。
生成したワークを、パスからルーティングルールへ、ルーティングルールからパスへ格納することで、コンベア上に流します。
コネクターを接続します。
RoutingRuleのポート1を選択します。
ワークをパスからルーティングルールに入力するため、[プロパティ]ウィンドウの[入力]にチェックをつけます。
[接続]でTwoWayPathを、[ポート]でOutputを選択します。
TwoWayPathのOutputを選択すると、自動的に接続されています。
RoutingRuleのポート2を選択します。
ワークをルーティングルールからパスに出力するため、[プロパティ]ウィンドウの[出力]にチェックをつけます。
[接続]でTwoWayPath_2を、[ポート]でInputを選択します。
TwoWayPath_2のInputを選択すると、自動的に接続されています。
RoutingRuleのポート3を選択します。
ポート3も同様に、ワークをルーティングルールからパスに出力するため、[プロパティ]ウィンドウの[出力]にチェックをつけます。
[接続]でTwoWayPath_3を、[ポート]でInputを選択します。
TwoWayPath_3のInputを選択すると、自動的に接続されています。
シミュレーションを実行します。
[接続]グループの[シグナル]をクリックし、コンベアを選択することで、シグナルエディタを表示します。
画面右下の[コンポーネントプロパティ]をクリックし、[コンポーネントプロパティ]ウィンドウを表示します。
[コンポーネントプロパティ]ウィンドウの[既定]タブをクリックします。
ForwardはTrue、RouteはFalseであることを確認します。
PathSignalとBooleanSignalをオンにし、ワークを生成します。
ワークはルートAに流れます。
[コンポーネントプロパティ]ウィンドウでRouteをTrueに変更し、ワークを生成します。
ワークはルートBに流れます。
分岐があるコンベアにワークを流し、ルートを変更する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

装置の表示状態を制御しよう

パイソンスクリプト（Python）を使用して、装置の一部を非表示にする方法
関連動画：コンポーネントの表示/非表示を切り替えよう
https://youtu.be/5A_BqAGfxF0
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_103.zip

装置の表示状態を制御する方法を説明します。
PythonAPIを使用して、装置の表示/非表示を制御します。
今回は、ロボットで説明します。
eカタログの[タイプ別モデル]-[Robots]-[Mitsubishi Electric]を選択します。
[RV-7FRL]を追加します。
[モデリング]タブを開きます。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を開きます。
パイソンスクリプトダイアログが開くため、デフォルトで記述されているソースコードを1行目以外削除します。
comp = getComponent()と記述し、Pythonスクリプトを設定しているコンポーネントを取得します。
comp.Visibleと記述し、3Dワールドのコンポーネントの表示/非表示を切り替えます。
Trueのときに表示、Falseのときに非表示になります。
非表示にするため、Falseと記述します。
app = getApplication()と記述し、アプリケーション情報を取得します。
app.render()と記述し、3Dワールドに描画します。
コンパイルボタンをクリックします。
ロボットが3Dワールドから非表示になります。
ロボットを表示します。
FalseをTrueにします。
コンパイルボタンをクリックします。
ロボットが3Dワールドに表示されます。
ロボットの特定のノードを非表示にします。
ルートノードを非表示にします。
[コンポーネントグラフ]ウィンドウのプロパティとビヘイビアを非表示にします。
ノードツリーをすべて展開するため、「＋」を選択します。
ロボットのルートノードと各軸のノードがあります。
comp.VisibleにNodeを記述します。
TrueをFalseにします。
コンパイルボタンをクリックします。
ロボットのルートノードが、3Dワールドから非表示になります。
FalseをTrueにします。
コンパイルボタンをクリックします。
ルートノードが3Dワールドに表示されます。
指定したノードとその子ノードを非表示にします。
3DワールドのロボットのJ2をダブルクリックします。
紫色でハイライトされた箇所が、J2のノードと子ノードということがわかります。
comp.NodeVisibleを削除します。
axisTwo = comp.findNode("J2")と記述し、J2のノードを取得します。
axisTwo.Visible = Falseと記述し、指定したノードを非表示にします。
コンパイルボタンをクリックします。
紫色でハイライトされていたロボットのJ2とその子ノードが、3Dワールドから非表示になります。
FalseをTrueにします。
コンパイルボタンをクリックします。
J2のノードと子ノードが3Dワールドに表示されます。
指定したノードのみを非表示にします。
axisTwo.VisibleにNodeを記述します。
TrueをFalseにします。
コンパイルボタンをクリックします。
ロボットのJ2のみが、3Dワールドから非表示になります。
FalseをTrueにします。
コンパイルボタンをクリックします。
J2のノードが3Dワールドに表示されます。
シミュレーション実行中にロボットの特定のノードを非表示にします。
axisTwo.NodeVisibleとapp.renderを削除します。
sim = app.Simulationと記述し、シミュレーション情報を取得し、シミュレーション実行中の動作を制御します。
sim.OnStartStop = ShowAxis2と記述し、シミュレーションが開始または停止したときに、ShowAxis2という関数を呼び出します。
def ShowAxis2と記述し、ShowAxis2の関数を作成します。
第一引数はシミュレーションの情報を格納する変数を定義します。
第二引数はシミュレーション実行中にTrue、停止中にFalseとなるブール型の変数を定義します。
if isRunning: axisTwo.NodeVisible = Falseと記述し、シミュレーション実行中は指定したノードを非表示にします。
else: axisTwo.NodeVisible = Trueと記述し、シミュレーション停止中はノードを表示します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ロボットのJ2のみが、3Dワールドから非表示になります。
シミュレーションを一時停止します。
J2のノードが3Dワールドに表示されます。
シミュレーションを再生します。
再度、ロボットのJ2のみが、3Dワールドから非表示になります。
3DワールドでロボットのJ1を選択します。
[フィーチャプロパティ]ウィンドウの[表示]のチェックを外すと、J1が非表示になります。
パイソンスクリプトでの表示/非表示と[フィーチャプロパティ]ウィンドウの[表示]は連動しないことがわかります。
装置の表示状態を制御する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

統計情報のダッシュボードを作成しよう(1/2)

パイソンスクリプト（Python）を使用して、統計情報のダッシュボードに、オリジナルの行数・列数のレイアウトを追加する方法
関連動画：統計情報を表示してみよう
https://youtu.be/cc2P9ve4T6k
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_106_p1.zip

統計情報のダッシュボードを作成する方法を説明します。
ダッシュボードとは、収集したデータをグラフにして、分かりやすい形で可視化した画面のことです。
パート1では、パイソンスクリプトを使用して、統計情報ウィンドウに新しいタブとレイアウトを作成します。
[モデリング]タブを開きます。
[コンポーネント]-[新規]を選択し、コンポーネントを作成します。
[ジオメトリ]-[フィーチャ]-[ブロック]を選択し、ブロックを作成します。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
パイソンスクリプトダイアログが開くため、デフォルトで記述されているソースコードを1行目以外削除します。
app = getApplication()と記述し、アプリケーション情報を取得します。
dash = app.Dashboardと記述し、統計のダッシュボードを取得します。
print dashと記述し、[出力]ウィンドウにダッシュボードの情報を表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウにダッシュボードの情報が表示されます。
print関数を削除します。
tab = dash.SelectedTabと記述し、ダッシュボード内のタブを取得します。
print tabと記述し、[出力]ウィンドウにタブの情報を表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウにタブの情報が表示されます。
print関数を削除します。
layouts = tab.Layoutsと記述し、タブのレイアウト情報を取得します。
print layoutsと記述し、[出力]ウィンドウにタブのレイアウト情報を表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウにタブのレイアウト情報が表示されます。
タブのレイアウトはリストで表されていることが分かります。
リストは、レイアウト名、表示名、列、行、列がまたがる数、行がまたがる数が定義されています。
新しいレイアウトを作成します。
print関数を削除します。
new_layoutという変数を作成し、変数にレイアウトの要素をリストとして格納します。
リストを作成します。
レイアウトの名前をExampleにします。
1つのレイアウト内に表やグラフを配置するためのエリアを2つ用意するため、リストの中にリストを2つ追加します。
1つ目のリストの名前をA1、2つ目のリストの名前をA2にします。
A1が配置されている列を0、行を0にします。
レイアウト内でエリアが何行、何列にまたがるかを定義します。
A1は10列と5行にまたがるようにします。
A2はA1の下に配置します。
A2が配置されている列を0にします。
A1で5行分使用しているため、A2が配置されている行は5行にします。
A2は10列と5行にまたがるようにします。
layouts.append(new_layout)と記述し、新しいレイアウトをリストとして追加します。
tab.Layouts = layoutsと記述し、追加したレイアウトをタブに戻します。
コンパイルボタンをクリックします。
ダッシュボードを確認します。
[ホーム]タブを開きます。
[統計情報]を右クリックし、クイックアクセスツールバーへ追加します。
[統計情報]のアイコンをクリックすると、統計情報のウィンドウが表示されます。
[レイアウトを選択]を確認すると、A1とA2の名前が付いたレイアウトが追加されていることがわかります。
作成したレイアウトを選択すると、[Example]のレイアウト名と説明が表示されます。
[クリエイト]ボタンをクリックすると、A1とA2のエリアにグラフの選択肢が表示されます。
列と行がまたがる数に制限はありません。
レイアウトとエリアはdashboradのサイズに応じて拡大縮小されます。
例えば、A1を[0,0,2,1]、A2を[0,1,2,1]にすると、先ほど設定したダッシュボードに比べてサイズが縮小されていることがわかります。
ダッシュボードに新しいタブを作成し、レイアウトを追加します。
[モデリング]タブを開きます。
パイソンスクリプトを開きます。
7行目以下のソースコードをコメントアウトします。
コメントアウトするには、アポストロフィーをコメントアウトしたいソースコードの最初と最後に3つずつ付けます。
new_tab = dash.createTabと記述し、ダッシュボードに新しいタブを作成します。
第一引数はタブの名前を定義します。
名前はExampleにします。
第二引数はTrueにし、新しいタブをダッシュボードで選択したタブにできるようにします。
new_layoutをコピーし、new_tabの下に貼り付けます。
new_tab.Layouts = [new_layout]と記述し、新しいタブに新しいレイアウトのみ追加します。
コンパイルボタンをクリックします。
統計情報のウィンドウを開くと、Exampleのタブが追加されたことがわかります。
Exampleの名前のレイアウトのみ表示されています。
統計情報のウィンドウを閉じます。
再度統計情報のウィンドウを開くと、Exampleのタブが追加されたままになっています。
統計情報のタブを全て閉じます。
[レイアウトを選択]を確認すると、Exampleのレイアウトは削除されます。
統計情報のダッシュボードを作成する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

統計情報のダッシュボードを作成しよう(2/2)

アドオンを使用して、統計情報のダッシュボードに、オリジナルの行数・列数のレイアウトを追加する方法
関連動画：統計ダッシュボードのテンプレートチャートを使ってみよう
https://youtu.be/GvcQt8x4ClU
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_106_p2.zip

統計情報のダッシュボードを作成する方法を説明します。
パート1では、パイソンスクリプトを使用して、統計情報ウィンドウに新しいタブとレイアウトを作成しました。
パート2では、アドオンを使用して、統計情報ウィンドウに新しいタブとレイアウトを作成します。
パート1で使用したファイル、もしくは、[Create Tabs and Layouts in Statistics Dashboard - Part1_after.vcmx]をダウンロードし、開きます。
アドオンはテキストエディタで作成します。
今回は、メモ帳を使用します。
from vcCommand import *と記述し、Geminiのコマンドファイルを呼び出します。
cmd = getCommand()と記述し、コマンドを取得します。
コマンドを取得することで、ボタンなどをGeminiに追加することができます。
def first_state():と記述し、first_stateの関数を作成します。
コマンドの初期状態を定義します。
Geminiのパイソンスクリプトの3行目～9行目をコピーします。
メモ帳に貼り付けます。
貼り付けたソースコードにスペースを追加します。
メモ帳ではタブを使用すると動作しないため、スペースを追加します。
addState()と記述し、first_state関数をコマンドとして追加します。
これで、コマンドファイルの作成は完了です。
ファイルを保存します。
今回は、[ドキュメント]-[MITSUBISHI]-[Gemini]-[1.46]-[My Commands]に保存します。
ファイル名を[testTabLayoutDashboard]、拡張子をPythonファイルの[.py]にし、保存します。
コマンドの初期化ファイルを作成します。
Geminiにコマンドを登録するには、初期化ファイルの作成が必要です。
ファイルを新規作成します。
from vcApplication import *と記述し、Geminiのプロパティやメソッドを呼び出します。
def OnAppInitializedと記述し、OnAppInitializedの関数を作成します。
OnAppInitializedは、Geminiを初期化し、ユーザインターフェースを表示するウィンドウが作成されたときに処理されます。
cmduri = getApplicationPath() + "testTabLayoutDashboard.py"と記述し、コマンドファイルのURIを作成します。
getApplicationPathは、GeminiのスクリプトのUriを文字列で返します。
通常は、アドオンで使用されるコマンドを登録するために使用されます。
cmd = loadCommand()と記述し、Geminiにコマンドを読み込みます。
第一引数はコマンドに付与するIDで、他のスクリプトやローカライズなどでコマンドを参照できるようにします。
ID名はTestDashboardにします。
第二引数はcmduriにし、コマンドのURIを指定します。
cmd.execute()と記述し、コマンドを実行します。
これで、コマンドの初期化ファイルの作成は完了です。
アプリケーションを起動すると、コマンドファイルのURIにアクセスされ、ダッシュボードに新しいタブとレイアウトが追加されます。
ファイルを[My Commands]に保存します。
initファイルはMy Commandsフォルダに置く必要があります。
コマンドファイルと同じフォルダに置く必要はありませんが、簡単に参照できるように同じフォルダに入れることをおすすめします。
ファイル名を[init]にします。
ファイル名の前後には、必ずアンダースコアを2つずつ付けます。
拡張子をPythonファイルの[.py]にし、保存します。
GeminiのVer.1.46を再起動します。
[ホーム]タブの[統計情報]を選択します。
統計情報のウィンドウにExampleのタブが追加されたことがわかります。
[レイアウトを選択]を確認すると、A1とA2の名前が付いたレイアウトが追加されていることがわかります。
統計情報のダッシュボードを作成する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

複数の3DCADデータを組み合わせてみよう

複数の3DCAD ファイルをインポートして組み合わせる方法
https://youtu.be/45oq-5oIraQ
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_007.zip

複数のジオメトリを、1つのコンポーネントに結合する方法を説明します。
複数のCADファイルをインポートし、1つのコンポーネントとして保存します。
2つのジオメトリファイルを用意します。
ジオメトリファイルをインポートすると、新しいコンポーネントが作成されるので、ジオメトリファイルを1つ、3Dワールドにドラッグ&ドロップします。
ファイルがインポートされます。
もう1つのジオメトリファイルをインポートします。
ファイルを 3Dワールドにドラッグ＆ドロップします。
ジオメトリはインポートされましたが、別のコンポーネントに含まれているため、ジオメトリを組み合わせ、1つのコンポーネントとして保存します。
コンポーネントの1つを、もう1つのコンポーネントに、アタッチすることもできますが、レイアウトには、2つのコンポーネントとして保存されています。
次に、2つのコンポーネントを1つのコンポーネントとして保存していきます。
コンポーネントを1つ選択し、[整列]のショートカットキーを使用します。
Shiftキーを押しながら、コンポーネントをドラッグし、もう1つのコンポーネントの上面にスナップします。
次に、コマンド[PNP]を使用し、コンポーネントを再配置します。
ジオメトリを、今あるコンポーネントから別のコンポーネントに移動させます。
コンポーネントを1つ選択し、[モデリング]タブに移動します。
コンポーネントグラフの下にある、ノードフィーチャツリーを展開し、ジオメトリフィーチャを選択します。
右クリックし、メニューから[コピー]を選択します。
次に、他のコンポーネントを選択し、コンポーネントグラフの下にある[Root]を選択し、その位置で右クリックし、メニューから[貼り付け]を選択します。
新しいジオメトリが、[Root]の下に移動したことが確認できます。
ジオメトリを別のコンポーネントに移動することができましたが、位置が正しくありません。
ジオメトリを移動させるには、ジオメトリが選択された状態で、[ツール]グループの[スナップ]をクリックし、スナップタイプを原点に設定し、スナップします。
新しいジオメトリを正しい位置に、移動させることができたので、古いコンポーネントを削除します。
古いコンポーネントを選択します。
選択することが難しい場合は、新しいジオメトリを選択した状態のまま、プロパティの[表示]のチェックを外すことで、古いコンポーネントのジオメトリを、選択することができます。
[コンポーネントグラフ]パネルに移動し、ルートノードを選択することで、[クリップボード]グループにある[削除]をクリックし、コンポーネント全体を削除することができるようになります。
古いコンポーネントは削除され、新しいジオメトリは非表示になっているので、何もないように見えます。
3Dワールドに表示されているコンポーネントをクリックし、コンポーネントグラフの下側で非表示にしたジオメトリを選択し、プロパティで、[表示]のチェックボックスにチェックをつけることで、再び表示することができます。
これで、2つの異なるCADファイルをインポートし、ジオメトリを1つのコンポーネントに結合することができました。
[コンポーネント]グループの[保存]をクリックし、変更点を保存します。
2つの別々のコンポーネントではなく、1つのコンポーネントとして保存しています。
一部を除き、eカタログのテンプレートのコンポーネントを使用し、ソースファイルのジオメトリをコピーし、そのテンプレートに貼り付け、古いコンポーネントを削除するため、
ロボットを効率的にモデリングできます。
複数のジオメトリを、1つのコンポーネントに結合する方法についての説明は以上となります。

=================================================================================

複数のジオメトリを切り替えてみよう

オリジナルの箱の見た目を、条件によって切り替え可能にする方法
https://youtu.be/h5naCWXOVaI
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_014.zip

コンポーネントのジオメトリコンテナについて説明します。
梱包した製品を流すため生産ラインで、サイズの異なる箱を管理、操作する必要があります。
サイズの異なる箱ごとに個別のコンポーネントを用意するのではなく、倉庫の在庫全体を一つのコンポーネントとし、ジオメトリを切り替えることで、それぞれ異なるサイズの箱を表示することができます。
3Dワールドにコンポーネントを作成します。
[コンポーネントグラフ]に移動し「Box」という名前のコンポーネントを確認します。
表示する箱のサイズを選択するためのプロパティがあります。
ノードフィーチャツリーには箱のサイズごとにコンテナがあり、ジオメトリをインポートすることができます。
XSを選択し[フィーチャプロパティ]に移動します。
コンテナを最適化し[オンデマンドロード]をオンにします。
多数のジオメトリがあり、表示するジオメトリを切り替える場合、[オンデマンドロード]をオンにします。
シミュレーションのパフォーマンスが向上します。
URIはソフトウェアでサポートされているCADファイルのステップファイルやJTファイルをインポートできます。
URI横のボタンをクリックし、XS.JPファイルを選択し[開く]ボタンをクリックします。
箱のジオメトリをインポートしました。
他のサイズのジオメトリもインポートします。
Sを選択し、S.JTファイルをインポートします。
Mを選択しM.JTファイルをインポートします。
Lを選択しL.JTファイルをインポートします。
Fを選択しF.JTファイルをインポートします。
Fサイズの箱は主に瓶を入れます。
選択されている箱を表示するためサイズのコンテナをSwitchにドラッグアンドドロップします。
表示する箱のサイズを選択できるようになりました。
XSサイズの箱が表示されていますが、コンポーネントプロパティの[BoxSize]を変更することで、S、M、L、Fと表示を切り替えることができます。
XSに戻します。
一つのコンポーネントで異なるものを表示することができます。
ジオメトリを切り替え、新しいものを追加します。
箱のサイズが異なる別の輸送サービスを使用する場合、ジオメトリを変更するため別のCADファイルをインポートすることができます。
URIを削除しCADファイルを選択します。
再度XSを選択します。
URIを使用するときのインポート設定は、[インポート]グループの[ジオメトリ]を使用したとき、最後に行った設定を参照しています。
CADファイルをインポートします。
[モデルをインポート]ウィンドウにオプションがあり、ジオメトリコンテナのURIを使用するとき最後に行った設定を参照します。
コンポーネントのジオメトリコンテナについての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

複数のワークを繋げて、物理演算で動かしてみよう

物理設定されたコンポーネント同士を固定し、お互いに物理的に干渉しあうように設定する方法
https://youtu.be/d4lok-QdmbA
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_066.zip

円柱とブロックを繋げて物理演算で動かす方法を説明します。
[モデリング]タブを開きます。
[コンポーネント]-[新規]を選択し、コンポーネントを作成します。
[ジオメトリ]-[フィーチャ]-[ブロック]を選択し、ブロックを作成します。
[フィーチャプロパティ]ウィンドウの[物理]の項目を展開すると、[干渉]という項目があります。
[干渉]を[box]に設定します。
[干渉]を[box]に設定すると、3Dワールド上には表示されませんが、ブロックの周りにボックスのようなものができます。
[出力]ウィンドウに「選択された干渉設定のために物理エンティティを追加しました。」と表示されます。
[コンポーネントグラフ]ウィンドウの[新規コンポーネント]-[ビヘイビア]を展開すると、[PhysicsEntity]が追加されていることがわかります。
シミュレーションを実行すると、マウスでブロックに力を加えることができます。
シミュレーションをリセットします。
ブロックに円柱を追加します。
[構造]-[リンクをクリエイト]を選択し、ブロックに新しいリンクを作成します。
[コンポーネントグラフ]ウィンドウを確認すると、[Link_1]が作成されたことがわかります。
[Link_1]のノードの原点を移動します。
[マニピュレーション]-[移動]が選択された状態で、ノードの原点の円をブロックのR側の面の中心までドラッグ＆ドロップします。
[ジオメトリ]-[フィーチャ]-[円柱]を選択し、円柱を追加します。
ノードの原点の向きに合わせて、円柱が作成されます。
[フィーチャプロパティ]ウィンドウで、円柱のサイズを変更します。
半径を25にします。
高さを300にします。
[物理]を展開し、[干渉]を[Precise]に設定します。
[Precise]は、フィーチャのジオメトリを中心に精密な形状を作成できます。
[コンポーネントグラフ]ウィンドウの[Link_1]-[ビヘイビア]を展開すると、物理エンティティが追加されたことがわかります。
[PhysicsEntity_2]を選択します。
[プロパティ]ウィンドウの[物理タイプ]を確認すると、[機構]が選択されています。
[機構]は、コンポーネントに外力が加わることで、コンポーネントが動作します。
シミュレーションを実行し、円柱にマウスで力を加えても、動かすことはできません。
ブロックにマウスで力を加えると、ブロックの動作に合わせて円柱を動かすことができます。
[PhysicsEntity_2]は[PhysicsEntity]に包括されているため、円柱に直接外力を加えることができません。
シミュレーションをリセットします。
[プロパティ]ウィンドウの[物理タイプ]を[物理内]に変更します。
シミュレーションを実行すると、円柱が重力の影響をうけるため、落下します。
また、ブロックと円柱にマウスで力を加えると、それぞれバラバラに動きます。
シミュレーションをリセットします。
円柱をブロックに取り付け、一緒に動作するようにします。
[動作設定]-[ビヘイビア]-[物理]-[ジョイント]を選択し、[Link_1]のビヘイビアに[PhysicsJointD6]を追加します。
[プロパティ]ウィンドウの[Parent]で、円柱の接続先を選択します。
円柱をブロックに取り付けるため、[新規コンポーネント]を選択します。
[Constraints]で、コンポーネントを動かす際の、ジョイントの移動や回転に制約を付けます。
[Free]は、動作の制限がありません。
[Limited]は、動作の範囲を指定します。
[Locked]は、動作を固定します。
今回は、全てのジョイントを固定させたいため、[Twist Motion]、[Swing1 Motion]、[Swing2 Motion]を[Lockd]にします。
シミュレーションを実行すると、重力によって円柱が床に接触します。
円柱を動かすと、円柱に合わせてブロックが動きます。
同様に、ブロックを動かすと、一緒に円柱が動きます。
シミュレーションをリセットします。
反対側の円柱の面に、ブロックを取り付けます。
[コンポーネントグラフ]ウィンドウで、ルートノードを選択します。
[構造]-[リンクをクリエイト]を選択し、ブロックに新しいリンクを作成します。
[コンポーネントグラフ]ウィンドウの[Link_1]と同じ階層に、[Link_2]が作成されたことがわかります。
[Link_2]のノードの原点を反対側の円柱の面まで移動します。
[リンクプロパティ]ウィンドウのX座標を400にします。
[ジオメトリ]-[フィーチャ]-[ブロック]を選択し、ブロックを追加します。
[フィーチャプロパティ]ウィンドウの[物理]を展開し、[干渉]を[Box]に設定します。
[コンポーネントグラフ]ウィンドウの[Link_2]-[ビヘイビア]を展開すると、物理エンティティが追加されたことがわかります。
[PhysicsEntity_3]を選択します。
[プロパティ]ウィンドウの[物理タイプ]を[物理内]に変更します。
シミュレーションを実行すると、最初に設定したボックスと円柱は一緒に動きますが、後から追加したブロックは一緒には動きません。
追加したボックスにもジョイントを設定する必要があります。
シミュレーションをリセットします。
[動作設定]-[ビヘイビア]-[物理]-[ジョイント]を選択し、[Link_2]のビヘイビアに[PhysicsJointD6_2]を追加します。
[プロパティ]ウィンドウの[Parent]で、ブロックの接続先を選択します。
ブロックを円柱に取り付けるため、[Link_1]を選択します。
[Constraints]で、全ての項目を[Locked]にします。
シミュレーションを実行します。
円柱を動かすと、左右のブロックが一緒に動きます。
同様に、ブロックを動かすと、他のブロックや円柱も一緒に動くことがわかります。
円柱とブロックを繋げて物理演算で動かす方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

物理的な力や物体の影響を受ける部品のモデリングをしよう

物理的な力や物体の影響を受ける部品を作成する方法
https://youtu.be/0OhiWHZBTwc

3Dワールドで物理演算をオンにし、物理的な力の影響を受ける部品をモデリングする方法を説明します。
コンポーネントを数点追加します。
eカタログの[タイプ別モデル]-[Basic Shapes]を展開します。
[Visual Components]をクリックします。
[Block Geo]、[Cylinder Geo]、[Sphere Geo(Ball)]を追加します。
追加した3つのコンポーネントは、3Dワールド上の床に配置されています。
コンポーネントを上に移動し、床から浮かせます。
コントロールキーを押しながら、3つのコンポーネントを選択します。
移動ツールで、コンポーネントをZ軸に沿って床より上に移動します。
シミュレーションを実行すると、物理演算がオンになりますが、コンポーネントは落下しません。
物理の影響を受けるコンポーネントを作るには、物理エンティティビヘイビアを追加する必要があります。
シミュレーションをリセットし、コンポーネントに物理設定をします。
ブロックを選択します。
[モデリング]タブを開きます。
[動作設定]-[ビヘイビア]-[物理]-[エンティティ]を作成します。
[プロパティ]ウィンドウに[物理タイプ]という項目があります。
[物理タイプ]は、[物理内]、[物理外]、[機構]、[コンテナ内]を選択できます。
デフォルトでは、「物理内」が設定されています。
シミュレーションを実行すると、ブロックが床に落下します。
シミュレーションの実行中に[マニピュレーション]の[インタラクティブ]を選択し、ブロックを操作すると、マウスでブロックに力を加えることができます。
シミュレーションを停止し、ブロックを動かそうとすると、物理はオフになっているため、動作しません。
ブロックをシミュレーション開始時の初期状態に戻したい場合、シミュレーションをリセットします。
物理演算はオフになるため、力を加えることはできません。
[プロパティ]ウィンドウの[物理タイプ]に戻ります。
[物理タイプ]を[物理外]に設定します。
シミュレーションを実行すると、ブロックは重力の影響を受けていないため、落下しません。
マウスで力を加えることもできません。
このように、物理エンティティビヘイビアを使用すると、コンポーネント内で個別に物理演算をオフにすることができます。
[プロパティ]ウィンドウの[物理タイプ]に戻ります。
[物理タイプ]を[機構]に設定します。
[機構]は、コンポーネントに外力が加わることで、コンポーネントが動作します。
シミュレーションを実行すると、ブロックは重力の影響を受けていないため、落下しません。
マウスでコンポーネントに力を加えることができます。
シミュレーションをリセットします。
[プロパティ]ウィンドウの[物理タイプ]に戻ります。
[物理タイプ]を[コンテナ内]に設定します。
[コンテナ内]は、物理内と似ていますが、シミュレーション中に、コンテナ内外へのコンポーネントの位置をトラッキングします。
シミュレーションを実行すると、今回は何も設定をしていないため、ブロックは落下しません。
シミュレーションをリセットします。
他の2つのコンポーネントにも、物理設定をします。
円柱を選択します。
[動作設定]-[ビヘイビア]-[物理]-[エンティティ]を作成します。
シミュレーションを実行すると、ブロックと円柱のコンポーネントが床に落下します。
シミュレーションをリセットします。
球体を選択します。
球体は、他のオブジェクトと衝突させるため、[干渉]設定を追加します。
[コンポーネントグラフ]ウィンドウにビヘイビアが何も設定されていない状態で、[Sphere]をクリックします。
[フィーチャプロパティ]ウィンドウの[物理]の項目を展開すると、[干渉]という項目があります。
[干渉]は、コンポーネントの周囲に形状を作ることで、[干渉]の設定をした他のオブジェクトと衝突させることができます。
[干渉]を未定義にすると、干渉は定義されません。
[干渉]を[None]にすると、干渉は無効になります。
パイソンスクリプトでは、未定義の記述ができないため、Noneが選択できるようになっています。
[干渉]を[box]に設定すると、3Dワールド上には表示されませんが、球体の周りにボックスのようなものができます。
[出力]ウィンドウに「選択された干渉設定のために物理エンティティを追加しました。」と表示されます。
[コンポーネントグラフ]ウィンドウの[Sphere Geo(Ball)]をクリックし、[コンポーネントプロパティ]ウィンドウを確認します。
[PhysicsEntity]を選択すると、自動的に物理ビヘイビアが[物理内]に設定されていることがわかります。
シミュレーションを実行すると、3つのコンポーネントがすべて床に落下します。
リセットして、もう一度球体を選択します。
[干渉]が[Box]に設定されている場合、[フィーチャプロパティ]ウィンドウの[Physics Collider Padding]で、円柱の周りにあるボックスの余白を設定できます。
[Precise]は、フィーチャのジオメトリを中心に精密な形状を作成できます。
[干渉]を[box]に戻し、球体をブロックに衝突させます。
ブロックを選択します。
[コンポーネントグラフ]ウィンドウの[Block Geo]を選択します。
[コンポーネントプロパティ]ウィンドウのZ座標を0にします。
球体を選択し、ブロックの上に移動します。
球体が、ブロックの辺より内側になるように移動します。
シミュレーションを実行すると、球体は落下して、ブロックの上に乗ります。
同様に、球体をブロックに衝突させます。
球体が、ブロックの辺の上より少し外側になるように移動します。
シミュレーションを実行すると、球体はブロックに跳ね返されます。
物理エンティティはコンポーネントのノード単位で作成されます。
シミュレーションをリセットし、動作を確認します。
ブロックを他の2つのコンポーネントから遠ざけ、床より上に移動します。
コンポーネントに別のノードを追加します。
[構造]-「リンクをクリエイト」をクリックします。
[コンポーネントグラフ]ウィンドウで「Link_1」を選択した状態で、[Link_1]をX軸もしくはY軸方向に移動し、ボックスの横にずらします。
コンポーネントの構造を表示したい場合は、[構造]-[表示」のチェックボックスを選択します。
左側が元のノードで、右側が作成したリンクです。
リンクに円錐を追加します。
[コンポーネントグラフ]ウィンドウで「Link_1」を選択した状態で、[ジオメトリ]-[フィーチャ]-[コーン]を選択し、円錐を追加します。
[フィーチャプロパティ]ウィンドウで、円錐のサイズを変更します。
高さを500にします。
溝底半径を300にします。
シミュレーションを実行すると、ブロックと円錐が床に落下します。
ルートノードのビヘイビアに[PhysicsEntity]が設定されているため、コンポーネントの全てのノードが物理の影響を受けることがわかります。
シミュレーションをリセットします。
[コンポーネントグラフ]ウィンドウの[Block Geo]-[ビヘイビア]-[PhysicsEntity]をドラッグ＆ドロップで、[Link_1]の[ビヘイビア]に移動します。
[Link_1]の[ビヘイビア]を展開すると、[PhysicsEntity]が紐づいていることががわかります。
シミュレーションを実行すると、円錐は落下し、ブロックは落下しません。
マウスでコンポーネントに力を加えると、円錐は動かすことができますが、ブロックは動きません。
[Link_1]のみ、物理の影響を受けることがわかります。
物理的な力や物体の影響を受ける部品のモデリングについての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

物理の影響を受けるコンテナを作成しよう

物理の影響を受けてワークが落下する、コンテナ（棚や箱）を作成する方法
https://youtu.be/mlwzr2pPImQ
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_080.zip

物理の影響を受けるコンテナを作成する方法を説明します。
コンポーネントを物理の影響を受けるコンテナとしてモデル化します。
[Physics Container Reference_before.vcmx]をダウンロードし、開きます。
配置されている棚の動作を確認します。
シミュレーションを実行すると、物理演算がオンになるため、棚と箱が床に落下します。
棚を動かすと、物理の影響を受け、棚が動いたり、倒れることがわかります。
シミュレーションをリセットします。
棚を追加します。
eカタログの[タイプ別モデル]-[Facilities - Interior]をクリックします。
検索ボックスに[shelf]と入力します。
[Storage Shelf]を追加します。
[コンポーネントプロパティ]ウィンドウの[Colums]に1を入力し、列を1つに変更します。
タイヤを追加します。
eカタログの[タイプ別モデル]-[Products and Containers]をクリックします。
[Car Type]を追加します。
シミュレーションを実行すると、既存の棚は物理の影響を受けていることがわかります。
新しく追加した棚やタイヤは床に落下せず、力を加えても動作しません。
物理の影響を受けるコンポーネントを作るには、物理エンティティビヘイビアを追加する必要があります。
シミュレーションをリセットし、コンポーネントに物理設定をします。
設定方法には2種類あります。
まずは、[モデリング]タブから設定します。
[モデリング]タブを開きます。
タイヤが選択された状態で、[動作設定]-[ビヘイビア]-[物理]-[エンティティ]を作成します。
[プロパティ]ウィンドウに[物理タイプ]という項目があります。
デフォルトでは、「物理内」が設定されています。
もう1つの方法で、新しく追加した棚に物理設定をします。
新しく追加した棚を選択します。
[フィーチャプロパティ]ウィンドウの[物理]を展開し、[干渉]を[Precise]に設定します。
[Precise]は、フィーチャのジオメトリを中心に精密な形状を作成できます。
[出力]ウィンドウに「選択された干渉設定のために物理エンティティを追加しました。」と表示されます。
[コンポーネントグラフ]ウィンドウの[Storage Shelf #3]を展開すると、[PhysicsEntity]が追加されていることがわかります。
シミュレーションを実行すると、新しく追加した棚が床に落下します。
棚やタイヤに力を加えると、動作することが分かります。
タイヤを1番下の棚に収納することもでき、物理の影響を受けていることがわかります。
シミュレーションをリセットします。
シミュレーション実行時に、新しく追加した棚にタイヤが収納されている状態にします。
下から2番目の棚に、整列のショートカットキーを使用して、タイヤを収納します。
タイヤを選択し、Shiftキーを押します。
赤い丸と青い線が表示されるため、Shiftキーを押した状態で、タイヤの底面付近を下から2つめの棚にドラッグ&ドロップします。
シミュレーションを実行すると、新しく追加した棚とタイヤが床に落下します。
棚を動かすと、タイヤが棚の側面から飛び出ることがわかります。
シミュレーションをリセットします。
タイヤを運ぶためのコンテナを追加します。
[ホーム]タブを開きます。
eカタログの[タイプ別モデル]-[Products and Containers]をクリックします。
[Euro Pallet]を追加します。
パレットに物理設定をします。
[モデリング]タブを開きます。
[動作設定]-[ビヘイビア]-[物理]-[エンティティ]を作成します。
タイヤを選択します。
タイヤをパレットの上に移動します。
タイヤを複製します。
[ホーム]タブを開きます。
タイヤをクリックすると、ミニツールバーが表示されます。
クローンのアイコンを選択すると、タイヤが複製されます。
複製したタイヤをパレットの上に移動します。
シミュレーションを実行すると、タイヤがパレットの上に落下します。
パレットに力を加えると、タイヤも一緒に動作することがわかります。
パレットを動かしすぎると、タイヤがパレットから飛び出します。
シミュレーションをリセットします。
パレットからタイヤが落下しないようにするためには、箱などの閉じられた空間を持つコンポーネントを使用する必要があります。
箱を追加します。
eカタログの[タイプ別モデル]-[Products and Containers]-[Box]を追加します。
Boxから物体が飛び出さないように、側面と底面に物理設定をします。
[モデリング]タブを開きます。
Blockのフィーチャを選択し、側面に物理設定をします。
[フィーチャプロパティ]ウィンドウの[物理]を展開し、[干渉]を[Precise]に設定します。
Block_2のフィーチャを選択し、もう一方の側面に物理設定をします。
[フィーチャプロパティ]ウィンドウの[物理]を展開し、[干渉]を[Precise]に設定します。
Block_3のフィーチャを選択し、底面に物理設定をします。
[フィーチャプロパティ]ウィンドウの[物理]を展開し、[干渉]を[Precise]に設定します。
箱の中に入れるボールを追加します。
[ホーム]タブを開きます。
eカタログの[タイプ別モデル]-[Products and Containers]-[Ball]を追加します。
ボールに物理設定をします。
[モデリング]タブを開きます。
ボールを選択します。
[フィーチャプロパティ]ウィンドウの[物理]を展開し、[干渉]を[Precise]に設定します。
ボールを3つ複製します。
[ホーム]タブを開きます。
ボールをクリックすると、ミニツールバーが表示されます。
クローンのアイコンを選択すると、ボールが複製されます。
同様の操作を2回行い、ボールを合計で4つにします。
[マニピュレーション]-[PnP]が選択された状態で、ボールをドラッグ＆ドロップし、箱の中に入れます。
残りの3つのボールも同様に箱の中に入れます。
シミュレーションを実行すると、ボールが箱の中に留まります。
箱に力を加えると、箱の中でボールが移動することがわかります。
箱を横に倒すと、箱の上面からボールが飛び出ます。
物理の影響を受けるコンテナを作成する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

物理の影響を受けるコンベアを作成しよう(1/2)

部品が端で落下するコンベアの設定方法
https://youtu.be/rkowaldck5Y
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_074_p1.zip

物理の影響を受けるコンベアを作成する方法を説明します。
ワークをコンベアに流し、コンベアの端まで流れた後、落ちていくように設定します。
[モデリング]タブを開きます。
[コンポーネント]-[新規]を選択し、コンポーネントを作成します。
[コンポーネントプロパティ]ウィンドウで[名前]を「Physics Conveyor」にします。
[ジオメトリ]-[フィーチャ]-[ブロック]を選択し、ブロックを作成します。
作成したブロックをコンベアとして使用します。
[フィーチャプロパティ]ウィンドウでコンベアの寸法を変更します。
[長さ]を「1500」にします。
[幅]を「400」にします。
[高さ]を「700」にします。
コンベアの座標を変更します。
コンベアの幅の中心位置をY軸座標の原点に合わせます。
コンベアの幅が「400」のため、座標のY軸に「-200」を入力します。
これにより、コンベア上にワークを流す際に、原点のY軸の線に沿ってワークが配置されます。
コンベアの材質を変更します。
[マテリアル]を[metal]にします。
コンベアに物理設定をします。
[物理]を展開し、[干渉]を[box]に設定します。
[干渉]を[box]にすると、3Dワールド上には表示されませんが、コンベアの周りにボックスのようなものができます。
[出力]ウィンドウに「選択された干渉設定のために物理エンティティを追加しました。」と表示されます。
[コンポーネントグラフ]ウィンドウの[Physics Conveyor]-[ビヘイビア]を展開すると、物理エンティティが追加されたことがわかります。
[PhysicsEntity]を選択します。
[プロパティ]ウィンドウの[物理タイプ]を確認すると、[物理内]が選択されています。
[物理タイプ]を[機構]に設定します。
[機構]は、コンポーネントに外力が加わることで、コンポーネントが動作します。
コンベア上面のXY座標の原点を起点とし、+X軸方向にワークを流すためのルートを作成します。
[ジオメトリ]-[フィーチャ]-[フレーム]を選択し、フレームを追加します。
フレームの名前が表示されていない場合は、[フレームタイプ]の逆三角形のアイコンをクリックし、[フレーム]にチェックを入れます。
[マニピュレーション]-[移動]が選択された状態で、ピンクの丸をコンベア上面のXY座標の原点にドラッグ＆ドロップします。
フレームの向きがワールド座標の向きと一致していることを確認します。
向きに問題がない場合は、フレームを追加します。
[コンポーネントグラフ]ウィンドウのルートノードを選択します。
[ジオメトリ]-[フィーチャ]-[フレーム]を選択し、フレームを追加します。
ピンクの丸をコンベア上面中央にドラッグ＆ドロップします。
[コンポーネントグラフ]ウィンドウのルートノードを選択します。
[ジオメトリ]-[フィーチャ]-[フレーム]を選択し、フレームを追加します。
ピンクの丸をコンベア上面の+X軸方向の端にドラッグ＆ドロップします。
[動作設定]-[ビヘイビア]-[物理]-[パス]を選択し、パスを追加します。
パスが3つのフレームを通るように設定します。
[プロパティ]ウィンドウの[パス]をクリックします。
プラスボタンが表示されるため、クリックすると、[Add 'Connections' items]ダイアログが表示されます。
ワークを流す順にフレームを選択する必要があるため、始点の[フレーム]、中間点の[フレーム_1]、終点の[フレーム_2]を順番に選択します。
[Add 'Connections' items]ダイアログを閉じます。
[パス]を確認すると、選択した順にフレームが表示されていることがわかります。
コンベアにワークが入るときの接続インターフェースを設定します。
[動作設定]-[ビヘイビア]-[1対1接続]を選択します。
[プロパティ]ウィンドウの[セクションとフィールド]-[新規セクションを追加]ボタンをクリックします。
パスの先頭のフレームからコンポーネントを転送するため、[セクションフレーム]で[フレーム]を選択します。
[新規フィールドを追加]で[Flow]を選択します。
[Flow]は、コンテナ内のコンポーネントを別のコンテナに転送できます。
[Container]は、コンポーネントの送信または受信に使用するビヘイビアを定義します。
ワークはパスを通って入るため、[PhysicsPath]を選択します。
ワークが入ってくるため、[PortName]は[Input]を選択します。
コンベアからワークが出るときの接続インターフェースを設定をします。
[動作設定]-[ビヘイビア]-[1対1接続]を選択します。
[プロパティ]ウィンドウの[セクションとフィールド]-[新規セクションを追加]ボタンをクリックします。
パスの終点のフレームからコンポーネントを転送するため、[セクションフレーム]で[フレーム_2]を選択します。
[新規フィールドを追加]で[Flow]を選択します。
[Container]で、[PhysicsPath]を選択します。
ワークが出ていくため、[PortName]は[Output]を選択します。
コンベアの設定が完了したため、コンポーネントを保存します。
コンベアのルートノードを選択します。
[コンポーネント]-[保存]を選択します。
[コンポーネントを保存]ウィンドウの[保存]ボタンをクリックします。
保存ダイアログが表示されるため、任意の場所に保存します。
今回は、[My Models]に保存します。
[ドキュメント]-[MITSUBISHI]-[Gemini]-[1.45]-[My Commands]を開きます。
ファイル名はそのままにし、保存します。
[ホーム]タブを開きます。
eカタログの[マイモデル]選択すると、先ほど保存したコンベアが表示されます。
[マニピュレーション]-[PnP]が選択された状態で、コンベアをクリックすると、設定したインタフェースが表示されていることがわかります。
ワークを流し、コンベアの動作を確認します。
eカタログの[タイプ別モデル]-[Physics]を展開します。
[Visual Components]をクリックします。
[Physics Feeder]を追加します。
[マニピュレーション]-[PnP]が選択された状態で、フィーダーをコンベアの始点にドラッグ＆ドロップし、接続します。
[Product]に[Cylinder]が選択されているため、円柱が生成されます。
生成される円柱の高さを変更します。
[コンポーネントプロパティ]ウィンドウの[ProductParams]タブを開きます。
[CylinderHeight]を80にします。
[CylinderRadius]を50にします。
円柱の物理設定の干渉を変更します。
[PartPhysics]タブを開きます。
[AddColider]にチェックを入れると、[ColiderType]に[#Box]が表示されます。
[ColiderType]を[#Presice]に変更します。
[Precise]は、フィーチャのジオメトリを中心に精密な形状を作成できます。
シミュレーションを実行します。
Feederから円柱が生成され、コンベアのパスに沿って流れます。
円柱がコンベアの端まで流れた後、物理の影響を受けて落下します。
物理の影響を受けるコンベアを作成する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

物理の影響を受けるコンベアを作成しよう(2/2)

部品が物理の影響を受けながら斜面を流れるコンベアの設定方法
https://youtu.be/L8mZJNa_X7c
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_074_p2.zip

物理の影響を受けるコンベアを作成する方法を説明します。
パート1では、コンベアの水平な面の上でワークを流しました。
パート2では、コンベアに傾斜のある面を増やし、その上にもワークが流れるようにします。
パート1で作成したコンベア、もしくは、[Model a Physics Conveyor - Part1_after.vcmx]をダウンロードし、開きます。
コンベア上面に傾斜を作り、ワークを流します。
ワークを流すためにワークを押す力は、現状はパスに沿っており、フレームフィーチャによって定義されています。
コンベア上面にウェッジなどのジオメトリフィーチャを作成し、ワークを流す場合、ジオメトリを使用してワークを押す力を定義します。
これにより、コンベア上の傾斜や下降などに対応できます。
コンベアでは、事前に定義されたパスに沿ってワークを押しますが、ジオメトリを使用することで、ワークの方向を変更することもできます。
コンベア上に傾斜をつけたオブジェクトを追加します。
[モデリング]タブを開きます。
コンベアを選択します。
[ジオメトリ]-[フィーチャ]-[ウェッジ]を選択し、ウェッジを作成します。
[マニピュレーション]-[移動]が選択された状態で、ピンクの丸をコンベア上面の「フレーム」と「フレーム_1」の間にドラッグ＆ドロップします。
ウェッジの寸法を変更します。
[フィーチャプロパティ]ウィンドウの[より長い]に200を入力し、ウェッジの底面を長くします。
[より低い]に0を入力し、+X軸方向にある面の高さを0にすることで、ワークがウェッジを降りることができます。
[幅]に100を入力し、ワークが乗るように幅を広くします。
ワークが上る方向のウェッジを作成するため、[ミラーバック]にチェックを入れます。
[ミラーバック]は、Y軸を基準にウェッジを反転コピーし、左右対称のオブジェクトを作成します。
ウェッジに物理設定をします。
[物理]を展開し、[干渉]を[Precise]に設定します。
[Precise]は、フィーチャのジオメトリを中心に精密な形状を作成できます。
ウェッジの位置を調整します。
[フィーチャプロパティ]ウィンドウのX軸座標を0にします。
Xのアイコンをクリックすると、0になります。
ウェッジの幅の中心をパスの中心位置に合わせます。
Y軸の矢印を移動させるとメモリが表示されます。
マウスポインターをメモリ上に合わせると、現在の視点では、25mm毎にウェッジを移動させることができます。
[グリッドスナップ」の[自動サイズ]にチェックがない場合、指定したサイズでグリッドが表示されます。
ウェッジの幅は100mmのため、-50の位置に移動します。
X軸座標が450になるよう移動します。
ウェッジに入ってくるワークが上り下りするように設定します。
[コンポーネントグラフ]ウィンドウの[PhysicsConveyor]を展開し、[ビヘイビア]の[PhysicsPath]を選択します。
[プロパティ]ウィンドウの[プッシングフィーチャ]で、コンポーネント内のどのフィーチャがワークを押す力として動作するかを定義します。
プッシングフィーチャを設定する前に、プッシングフィーチャを設定しないとどのような動作になるか確認します。
シミュレーションを実行します。
ワークがウェッジに沿って流れていることがわかります。
物理パスとジオメトリが同じフィーチャツリーにあるため、物理パスはウェッジのジオメトリを使用することができ、ワークがウェッジに沿って流れています。
ウェッジの上面の長さが短かく、ワークが転がり落ちてしまうため、ウェッジの寸法を修正します。
シミュレーションをリセットします。
ウェッジを選択します。
[フィーチャプロパティ]ウィンドウの[より短い]に「100」を入力し、上面の長さを長くします。
底面との差がなくなり、傾斜が急になるため、[より長い]に「300」を入力し、底面の長さを短くすることで、傾斜を緩やかにします。
シミュレーションを実行します。
ウェッジからワークが転がり落ちることなく、スムーズに下りていくことがわかります。
シミュレーションをリセットします。
物理パスに沿ってワークを押しているため、ウェッジでワークを押すよう設定します。
コンベアを選択します。
[コンポーネントグラフ]ウィンドウの[PhysicsPath]を選択します。
[プロパティ]ウィンドウの[プッシングフィーチャ]で、コンポーネント内のどのフィーチャがワークを押す力として動作するかを定義します。
[プッシングフィーチャ]をクリックします。
プラスボタンが表示されるため、クリックすると、[Add 'Connections' items]ダイアログが表示されます。
[ウェッジ]を選択すると、[プッシングフィーチャ]に追加されたことがわかります。
[Add 'Connections' items]ダイアログを閉じます。
シミュレーションを実行します。
ワークがコンベアの手前で落下します。
[プッシングフィーチャ]でコンベアを選択していないため、コンベアがワークを押す力が動作しておらず、コンベアの手前で落下していることがわかります。
シミュレーションをリセットします。
プッシングフィーチャにコンベアを追加します。
[プロパティ]ウィンドウの[プッシングフィーチャ]をクリックします。
プラスボタンが表示されるため、クリックすると、[Add 'Connections' items]ダイアログが表示されます。
[ブロック]を選択すると、[プッシングフィーチャ]に追加されたことがわかります。
[Add 'Connections' items]ダイアログを閉じます。
シミュレーションを実行します。
ワークがウェッジに沿って流れていることがわかります。
シミュレーションをリセットします。
プッシングフィーチャに直接ウェッジを追加する代わりに、押し出しフィーチャを使用し、コンベア上にワークを流す方法を説明します。
押し出しフィーチャのノードの中にウェッジを入れて親子関係にする場合、ワークを押す力がどのように機能するか確認します。
ウェッジを選択します。
[フィーチャプロパティ]ウィンドウの[より短い]に「50」を入力し、上面の長さを短くします。
[ジオメトリ]-[フィーチャ]-[押し出し]を選択し、フレームを追加します。
[コンポーネントグラフ]ウィンドウに押し出しが追加されたことがわかります。
押し出しをウェッジの上にドラッグ&ドロップします。
ウェッジを押し出しの中にドラッグ&ドロップし、押し出しが親、ウェッジが子の親子関係にします。
ウェッジが+Z軸方向に押し出されているため、+X軸方向に変更します。
押し出しを選択します。
[フィーチャプロパティ]ウィンドウの[方向]で、押し出す方向を変更します。
Vectorの()内の数値は、XYZの順に押し出す方向を定義できます。
+Z軸方向に1が入力されているため、0にします。
+X軸方向に1を入力し、+X軸方向にウェッジを押し出します。
押し出しに物理設定をします。
[物理]を展開し、[干渉]を[#Precise]に設定します。
シミュレーションを実行します。
ワークがウェッジの上を流れることができず、手前で止まっていることがわかります。
[プッシングフィーチャ]で押し出しを選択していないため、ウェッジがワークを押す力が動作していません。
ウェッジは押し出しの子であるため、親である押し出しに押す力を設定する必要があります。
シミュレーションをリセットします。
[コンポーネントグラフ]ウィンドウの[PhysicsPath]を選択します。
[プロパティ]ウィンドウの[プッシングフィーチャ]をクリックします。
プラスボタンが表示されるため、クリックすると、[Add 'Connections' items]ダイアログが表示されます。
[押し出し]を選択すると、[プッシングフィーチャ]に追加されたことがわかります。
[Add 'Connections' items]ダイアログを閉じます。
シミュレーションを実行します。
ワークがウェッジに沿って流れていることがわかります。
シミュレーションをリセットします。
[プロパティ]ウィンドウの[プッシングフィーチャ]でウェッジを削除します。
シミュレーションを実行します。
ワークがウェッジに沿って流れていることがわかります。
ウェッジに押す力が設定されていない場合でも、親である押し出しに押す力を設定しているため、ウェッジはワークを押すことができます。
シミュレーションをリセットします。
[コンポーネントグラフ]ウィンドウのウェッジを選択します。
[フィーチャプロパティ]ウィンドウの[物理]-[干渉]をなしにします。
シミュレーションを実行します。
ワークがウェッジに沿って流れていることがわかります。
ウェッジに物理設定がない場合でも、親である押し出しに物理設定をしているため、ウェッジにワークを流すことができます。
物理の影響を受けるコンベアを作成する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

物理の影響を受けるフィーダーを作成しよう(1/2)

物理的な力や物体の影響を受けるフィーダーを作成する方法
https://youtu.be/b_HsFlMt3bw
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_100_p1.zip

物理の影響を受けるフィーダーを作成する方法を説明します。
コンポーネントを物理の影響を受けるフィーダーとしてモデル化し、フィーダーから生成したワークをコンベアに流します。
パート1では、フィーダーを作成し、モデルとして保存します。
[モデリング]タブを開きます。
[コンポーネント]-[新規]を選択し、コンポーネントを作成します。
[コンポーネントプロパティ]ウィンドウで名前をPhysics Feederにします。
[ジオメトリ]-[フィーチャ]-[ブロック]を選択し、ブロックを作成します。
作成したブロックをフィーダーとして使用します。
[フィーチャプロパティ]ウィンドウでフィーダーの寸法を変更します。
[長さ]を「500」にします。
[幅]を「500」にします。
[高さ]を「700」にします。
材質を変更します。
[マテリアル]を[transp_orange]にします。
フィーダーに物理設定をします。
[物理]を展開し、[干渉]を[Box]に設定します。
[干渉]を[Box]にすると、3Dワールド上には表示されませんが、フィーダーの周りにボックスのようなものができます。
[出力]ウィンドウに「選択された干渉設定のために物理エンティティを追加しました。」と表示されます。
[コンポーネントグラフ]ウィンドウの[Physics Conveyor]-[ビヘイビア]を展開すると、物理エンティティが追加されたことがわかります。
[PhysicsEntity]を選択します。
[プロパティ]ウィンドウの[物理タイプ]を確認すると、[物理内]が選択されています。
[物理タイプ]を[機構]に設定します。
[機構]は、コンポーネントに外力が加わることで、コンポーネントが動作します。
フィーダー上面の中心を起点とし、+X軸方向にワークを流すためのルートを作成します。
[ジオメトリ]-[フィーチャ]-[フレーム]を選択し、フレームを追加します。
フレームの名前が表示されていない場合は、[フレームタイプ]の逆三角形のアイコンをクリックし、[フレーム]にチェックを入れます。
[マニピュレーション]-[移動]が選択された状態で、ピンクの丸をフィーダー上面の中心にドラッグ＆ドロップします。
フレームの向きがワールド座標の向きと一致していることを確認します。
向きに問題がない場合は、フレームを追加します。
[コンポーネントグラフ]ウィンドウのルートノードを選択します。
[ジオメトリ]-[フィーチャ]-[フレーム]を選択し、フレームを追加します。
ピンクの丸をFeeder上面のR側のエッジの中央にドラッグ＆ドロップします。
フレームの向きがワールド座標の向きと一致していないことがわかります。
[フィーチャプロパティ]ウィンドウのRyが90°になっています。
Ryのアイコンをクリックし、0にします。
フレームの向きがワールド座標の向きと一致したことがわかります。
[動作設定]-[ビヘイビア]-[コンポーネントクリエイター]を選択します。
コンポーネントクリエイターは、シミュレーション中にワークを生成します。
[動作設定]-[ビヘイビア]-[ワンウェイパス]を選択します。
ワンウェイパスは、フレームフィーチャに沿ってワークを流すことができます。
ワンウェイパスが2つのフレームを通るように設定します。
[プロパティ]ウィンドウの[パス]をクリックします。
プラスボタンが表示されるため、クリックすると、[Add 'Path' items]ダイアログが表示されます。
ワークを流す順にフレームを選択する必要があるため、始点の[フレーム]、終点の[フレーム_1]を順番に選択します。
[Add 'Path' items]ダイアログを閉じます。
[パス]を確認すると、選択した順にフレームが表示されていることがわかります。
コンポーネントクリエイターが生成したワークをワンウェイパスに転送し、フレームを始点としてフレーム_1に向かって流します。
[コンポーネントグラフ]ウィンドウのコンポーネントクリエイターとワンウェイパスを展開すると、転送用のポートがあることがわかります。
コンポーネントクリエイターのOutputを選択します。
[プロパティ]ウィンドウの[接続]でOneWayPathを選択します。
[ポート]でInputを選択します。
ワークをコンベアなど他のコンポーネントに転送するには、接続インターフェースを設定する必要があります。
[動作設定]-[ビヘイビア]-[1対1接続]を選択します。
[プロパティ]ウィンドウの[セクションとフィールド]-[新規セクションを追加]ボタンをクリックします。
パスの終点のフレームからコンポーネントを転送するため、[セクションフレーム]で[フレーム_1]を選択します。
[新規フィールドを追加]で[Flow]を選択します。
[Flow]は、コンテナ内のコンポーネントを別のコンテナに転送できます。
[Container]は、コンポーネントの送信または受信に使用するビヘイビアを定義します。
ワークはパスを通るため、[OneWayPath]を選択します。
ワークが出ていくため、[PortName]は[Output]を選択します。
フィーダーの設定が完了したため、コンポーネントを保存します。
フィーダーのルートノードを選択します。
[コンポーネント]-[保存]を選択します。
[コンポーネントを保存]ウィンドウの[保存]ボタンをクリックします。
保存ダイアログが表示されるため、任意の場所に保存します。
今回は、eカタログに自作のモデルを表示するため、[My Models]に保存します。
[ドキュメント]-[MITSUBISHI]-[Gemini]-[1.46]-[My Models]を開きます。
ファイル名はそのままにし、保存します。
[ホーム]タブを開きます。
eカタログの[マイモデル]を選択すると、先ほど保存したフィーダーが表示されます。
物理の影響を受けるフィーダーを作成する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

物理の影響を受けるフィーダーを作成しよう(2/2)

物理的な力や物体の影響を受ける部品を作成し、フィーダーからコンベアに流す方法
https://youtu.be/KUY-fZFIM3w
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_100_p2.zip

物理の影響を受けるフィーダーを作成する方法を説明します。
パート1では、フィーダーを作成し、モデルとして保存しました。
パート2では、ワークを作成し、フィーダーからコンベアに流します。
パート1で作成したフィーダー、もしくは、[Model a Physics Feeder - Part1_after.vcmx]をダウンロードし、開きます。
物理の影響を受けるワークを作成します。
eカタログの[タイプ別モデル]-[Basic Shapes]を展開します。
[Cylinder Geo]を追加します。
[コンポーネントプロパティ]ウィンドウを確認すると、物理設定の項目がないことがわかります。
つまり、円柱は物理の影響を受けていない状態です。
円柱に物理の設定を追加します。
[モデリング]タブを開きます。
[動作設定]-[ビヘイビア]-[物理]-[エンティティ]を選択します。
[コンポーネントグラフ]ウィンドウに[PhysicsEntity]が追加されていることがわかります。
[プロパティ]ウィンドウの[物理タイプ]を確認すると、[物理内]が選択されています。
ワークの設定が完了したため、コンポーネントを保存します。
ワークのルートノードを選択します。
[コンポーネント]-[名前をつけて保存]を選択します。
[コンポーネントを保存]ウィンドウの[名前]をPhysics Cylinder Geoにします。
[名前をつけて保存]ボタンをクリックします。
保存ダイアログが表示されるため、任意の場所に保存します。
今回は、eカタログに自作のモデルを表示するため、[My Models]に保存します。
[ドキュメント]-[MITSUBISHI]-[Gemini]-[1.46]-[My Models]を開きます。
ファイル名はPhysics CylinderGeoに変更し、保存します。
[ホーム]タブを開きます。
eカタログの[マイモデル]を選択すると、先ほど保存した円柱が表示されます。
円柱はフィーダーから生成されるワークとして使用し、3Dワールド上では不要のため、円柱を右クリックし削除します。
フィーダーをクリックします。
[コンポーネントプロパティ]ウィンドウの[ComponentCreator]タブを開きます。
[インターバル]はワークが何秒の間隔で生成されるかを設定します。
[リミット]は生成できるワークの数を設定します。
[パーツ]は生成されるワークのコンポーネントを設定します。
[パーツ]の横にある3つの点のアイコンを選択します。
ファイルを開くダイアログが表示されるため、[Physics CylinderGeo]を選択し、開きます。
[パーツ]に選択したファイルのパスが入力されていることがわかります。
シミュレーションを実行します。
円柱のワークが生成されます。
シミュレーションを一時停止し、ワークを選択します。
[コンポーネントプロパティ]ウィンドウの[Physics Entity]タブを開きます。
[物理タイプ]に機構が設定されていることがわかります。
シミュレーションをリセットします。
フィーダーを選択します。
黄色の矢印で接続用のインタフェースが設定されていることがわかります。
コンベアを追加します。
eカタログの[タイプ別モデル]-[Physics]をクリックします。
[Conveyor(Physics)]を追加します。
[マニピュレーション]-[PnP]が選択された状態で、コンベアをフィーダーに接続します。
フィーダーの矢印を確認すると、黄色から緑色になっているため、接続されていることがわかります。
シミュレーションを実行します。
フィーダーからワークが生成され、コンベアに流れた後、床に落下します。
落下したワークに力を加えると、ワークが物理の影響を受けて動きます。
シミュレーションをリセットします。
PnPが選択された状態で、コンベアを移動し、接続を解除します。
物理設定がない通常のコンベアを接続します。
eカタログの[タイプ別モデル]-[Conveyors]を展開します。
[Visual Conponents]を選択します。
[Conbeyor]を追加します。
[マニピュレーション]-[PnP]が選択された状態で、コンベアをフィーダーに接続します。
シミュレーションを実行します。
フィーダーからワークが生成され、コンベアに流れます。
シミュレーションを一時停止します。
物理パスではなく、ワンウェイパスを使用したため、物理設定のないコンベアにワークを転送することができます。
ワークを選択します。
[コンポーネントプロパティ]ウィンドウの[Physics Entity]タブを開きます。
[物理タイプ]に機構が設定されていることがわかります。
シミュレーションを再生します。
ワークがコンベアの端に到達後、消えることがわかります。
コンベアに物理設定がされていないため、ワークがどこにも接続されず、消滅します。
シミュレーションをリセットします。
通常のコンベアの接続を解除し、再度物理設定があるConveyorを接続します。
シミュレーションを実行します。
フィーダーからワークが生成され、コンベアに流れた後、床に落下します。
物理設定の有無で動きが変わることがわかります。
今回は説明しませんが、Pythonスクリプトを使用して、オブジェクトの物理タイプを機構から物理内に変更することもできます。
物理の影響を受けるフィーダーを作成する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

変数ペアのエクスポート・インポートをしてみよう

PLCと通信する変数ペアの一覧表をエクスポート、インポートし、変数ペアを一括で設定する方法
https://youtu.be/h-BXQW2372U
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_160.zip

変数ペアの一覧表をエクスポート、および、インポートし、変数ペアを一括で設定する方法について説明します。
変数ペアとは、Gemini側のシミュレーション変数と、PLC側のサーバー変数を対とすることです。
[接続性]タブで、シミュレーション変数と、サーバー変数を1つずつ選択し、ペアを作成します。
三菱電機製品のみ、CSVファイル形式で、変数ペアをエクスポート・インポートできます。
OPC UAサーバーを経由し、他社製品と接続する場合、XMLファイル形式である必要があります。
[コンフィグ]グループから、[エクスポート]、または[インポート]を選択することで、XMLファイル形式でエクスポート、またはインポートできます。
多くの変数ペアを設定する場合、変数ペアのエクスポート・インポート機能は便利です。
付属ファイル「VariablePairs_before.vcmx」を開きます。
シグナルで制御されたアームが配置されています。
シミュレーションを実行し、[接続]グループの[シグナル]を選択することで、アームを動作させることができます。
[コンポーネントプロパティ]ウィンドウの、[Front_End]から[Close_End]は、動作の完了を通知する項目です。
シミュレーションをリセットします。
GeminiとPLC間で送受信する変数の一覧表を、CSVファイル形式で書き出します。
[接続性]タブを開きます。
[接続性]タブが表示されない場合、[ファイル]タブを開き、[オプション]の[アドオン]で[接続性]を有効にする必要があります。
Geminiを一度再起動することで、[接続性]タブを表示できます。
PLCとの接続設定を追加します。
[接続性コンフィグ]ウィンドウの[MITSUBISHI ELECTRIC FA]を選択します。
右クリックでメニューを開き、[サーバーを接続]を選択することで、接続設定を追加できます。
[サーバー]グループの[変数ペアをエクスポート]を選択し、変数の一覧表を書き出します。
[エクスポート設定]ウィンドウで、書き出す変数を選択します。
[送信方向]では、変数の値を送信する方向を選択できます。
最初に、GeminiからPLCへ送信する変数を追加します。
[0:シミュレーションからサーバーへ]を選択します。
[追加項目]では、変数の種類、[コンポーネント]では、変数が設定されている装置を指定できます。
アームの動作完了を通知する変数には、[コンポーネントプロパティ]を使用しているため、[追加項目]で、[コンポーネントプロパティ]のみ選択します。
[コンポーネント]で、[Arm]を選択し、[追加]をクリックします。
[エクスポート一覧]に、変数が追加されたことがわかります。
ボタンを押した時、PLCのプログラムを開始するため、[コンポーネント]で[HMI Button]を選択し、[追加]をクリックします。
[IsPressed]は、ボタンを押したことを通知する変数、[ButtonDiameter]は、ボタンの半径を変更する変数です。
[エクスポート一覧]で、変数を選択し、[削除]をクリックすることで、[エクスポート一覧]から削除できます。
今回、ボタンの半径は必要ないため、[ButtonDiameter]を削除します。
[ButtonDiameter]を選択し、[削除]をクリックします。
次に、PLCからGeminiへ送信する変数を追加します。
[送信方向]を[1:サーバーからシミュレーションへ]に変更します。
アームの動作を指示する変数には、[シグナル]を使用しているため、[追加項目]で、[シグナル]のみ選択します。
[コンポーネント]で、[Arm]を選択し、[追加]をクリックします。
[エクスポート]をクリックします。
[変数ペアをエクスポート]ウィンドウで、CSVファイルを保存する場所を指定できます。
ファイル名は「サーバ2」です。
通常は、サーバーと同様の名前で問題ありません。
本動画では、エクスポート・インポートの結果を確認するため、名前を変更しています。
インポートするファイル名が、エクスポート元と同じ場合、上書き保存されず、同じ名前のサーバが並びます。
[保存]をクリックすると、「処理を実行しますか？データ量が多い場合、時間がかかります。」という確認メッセージが表示されます。
[はい]を選択します。
問題がない場合、「エクスポートに成功しました。」と表示されるため、[OK]をクリックします。
[エクスポート設定]ウィンドウの、[キャンセル]をクリックし、閉じます。
CSVファイルを開きます。
A列から、[送信方向]、[コンポーネント]、[プロパティ]、[ビヘイビア]、[シミュレーション変数とペアとなるサーバー変数]、[サーバー変数のデータ型]が表示されています。
E列に、シミュレーション変数とペアとなるサーバー変数を入力します。
E3に、X0と入力します。
シミュレーション変数Front_Endと、サーバー変数X0がペアです。
同様に、E4からE13に、X1からX10と入力します。
E14に、Y0と入力します。
E15からE23は、Y1からY9です。
サーバー変数のデータ型を設定します。
F3に、BOOLと入力します。
今回、データ型はすべてBOOLです。
CSVファイルの変更を保存し、閉じます。
Geminiの画面を表示します。
CSVファイルを読み込み、変数ペアを一括で設定します。
[サーバー]グループの[変数ペアをインポート]を選択することで、CSVファイル形式の変数ペア一覧表を読み込むことができます。
[変数ペアのインポート]ウィンドウで、「サーバ2」を選択し、[開く]をクリックします。
「処理を実行しますか？データ量が多い場合、時間がかかります。」という確認メッセージが表示されます。
[はい]を選択します。
問題がない場合、「インポートに成功しました。」と表示されるため、[OK]をクリックします。
[接続性コンフィグ]ウィンドウに、[サーバ2]が追加されたことがわかります。
読み込んだ変数ペアを確認します。
[ウィンドウ]グループの[変数を表示]を選択することで、[接続済変数]ウィンドウを表示できます。
[接続済変数]ウィンドウで、[サーバ2]、[シミュレーションからサーバーへ]、[サーバーからシミュレーションへ]を展開します。
CSVファイルで設定したシミュレーション変数とサーバー変数のペアが、表示されています。
PLCのシミュレーションを開始します。
今回は、GX Works3を使用します。
付属ファイル「Test.gx3」を開きます。
[デバッグ]をクリックし、[シミュレーション]の[シミュレーション開始]を選択します。
Geminiの画面を表示し、Gemini側の接続設定を変更します。
[接続性コンフィグ]ウィンドウの[MITSUBISHI ELECTRIC FA]から[サーバ2]を選択します。
[プロパティ]ウィンドウの[接続を編集...]をクリックすることで、接続設定を変更できます。
[接続を編集]ウィンドウの[PC側I/F]が、[GX Simulator3]であることを確認します。
[CPUシリーズ]、[CPUタイプ]、[システム番号]、[号機番号]をGX Works3と一致させます。
[GX Simulator3]ウィンドウで確認できます。
[CPUシリーズ]はRCPU、[CPUタイプ]はR16、[システム番号]と[号機番号]は1です。
[接続をテスト]をクリックし、接続を確認します。
「接続に成功しました。」と表示されるため、[OK]をクリックします。
[適用]をクリックします。
[接続性コンフィグ]ウィンドウで、[サーバ2]の右側にあるアイコンをクリックすることで、GeminiとGX Works3を接続できます。
動作を確認します。
[ホーム]タブを開きます。
[マニピュレーション]グループの[インタラクティブ]を選択した状態で、ボタンをクリックすることで、ボタンを押すことができます。
シミュレーションを実行し、ボタンをクリックします。
アームが動作しています。
[接続済変数]ウィンドウでは、シミュレーション変数とサーバー変数の値の変化を確認できます。
[シミュレーションからサーバーへ]は、シミュレーション変数と連動し、サーバー変数の値が変化します。
[サーバーからシミュレーションへ]は、サーバー変数と連動し、シミュレーション変数の値が変化します。
パソコンの環境により、通信に遅延が発生する場合があるため、注意が必要です。
シミュレーションをリセットします。
変数ペアの一覧表をエクスポート、および、インポートし、変数ペアを一括で設定する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

録画する時のカメラの視点をPythonで設定しよう

録画する時のカメラの視点（カメラアニメーター）をPythonで設定する方法（関連動画：録画する時のカメラの視点を設定しよう）
https://youtu.be/8x-N88zCbQk
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_089.zip

録画する時のカメラの視点をPythonで設定する方法を説明します。
3Dワールドのカメラの位置をあらかじめ設定し、シミュレーション中に自動で動くようにします。
eカタログの[タイプ別モデル]-[Layouts]を開きます。
[Machine Tending]を追加します。
3Dワールドの視点を変更します。
L側からモデルの全体が見える位置に視点を調整します。
手前にあるコンベアの中心に視点の中心を合わせます。
コンベアの上面を右クリックし、[3Dビューの中心]をクリックします。
3Dワールドの視点をビューエディタに保存します。
ツールバーのビューエディタをクリックします。
[ビューエディタ]ウィンドウが表示されるため、プラスボタンをクリックすると、現在の視点が追加されます。
名前をView01に変更します。
3Dワールドをクリックし、[ビューエディタ]ウィンドウを閉じます。
視点を変更します。
コンベアに向かって視点をズームインします。
ツールバーのビューエディタのプラスボタンをクリックし、視点を追加します。
名前をView02に変更します。
視点を変更します。
視点をズームアウトと回転し、ロボットと加工機が映るように調整します。
ツールバーのビューエディタのプラスボタンをクリックし、視点を追加します。
名前をView03に変更します。
視点を変更します。
視点を回転し、コンベアと三次元測定機が映るように調整します。
ツールバーのビューエディタのプラスボタンをクリックし、視点を追加します。
名前をView04に変更します。
視点を変更します。
視点を回転し、加工機がL側、三次元測定機がR側になるように調整します。
ツールバーのビューエディタのプラスボタンをクリックし、視点を追加します。
名前をView05に変更します。
ビューエディタに保存したカメラの視点が、シミュレーション中に01から順番に再生されるようにアニメーションを設定します。
[ホーム]-[Camera]-[カメラアニメーター]から手動で設定することもできますが、今回はPythonで設定します。
[モデリング]タブを開きます。
ロボットを選択します。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を選択します。
パイソンスクリプトダイアログが開くため、ソースコードを削除します。
視点を変更する際に使用できるソースコードが、[ヘルプ]に用意されているため、コピーして使用します。
[ヘルプ]タブを開きます。
[パイソンAPI]をクリックすると、ヘルプダイアログが表示されます。
[目次]-[Japanese]-[vcApplication]を開きます。
[メソッド]をクリックし、[レイアウト項目]までスクロールすると、createLayoutItemがあります。
createLayoutItemは、レイアウトに関するアイテムを作成することができます。
createLayoutItemの定数は、LayoutItemのリンクをクリックすると、確認できます。
レイアウトアイテム定数にViewAnimationがあります。
ViewAnimationは、シミュレーション中にカメラを動かして、視点を変更しながら録画することができます。
vcViewAnimationのリンクをクリックすると、動作の説明や仕組みが表示されます。
スクロールすると、vcViewAnimationの使用例が表示されます。
使用例のソースコードをコピーします。
パイソンスクリプトダイアログに貼り付けます。
def createViewAnimationと記述し、createViewAnimationの関数を作成しています。
関数を作成する必要はありませんが、カメラの動きを変更する必要がある場合、関数を定義しておくと役立ちます。
app = getApplication()と記述し、アプリケーション情報を取得します。
item = app.findLayoutItem("ViewAnimation")と記述し、ViewAnimationのレイアウトアイテムを取得します。
if not item:item = app.createLayoutItem("ViewAnimation")と記述し、ViewAnimationのレイアウトアイテムが存在しない場合、レイアウトアイテムを作成します。
prog = item.Programと記述し、ViewAnimationのプログラムを取得します。
routine = prog.MainRoutineと記述し、ViewAnimationのメインプログラムを取得します。
routine.clear()と記述し、メインプログラムをクリアし、初期化します。
21行目以降は、カメラの動きを設定しています。
21行目～23行目で、View01の視点を設定します。
「vs = routine.addStatement(VC_STATEMENT_VIEW)」と記述し、視点を移動します。
vs.Delay = 4.0と記述し、視点を4秒間かけて移動します。
vs.Viewと記述し、ビューエディタの中から移動したい視点を参照します。
視点がView1になっているため、View01に変更します。
26行目～30行目で、View02の視点を設定します。
vs = routine.addStatement(VC_STATEMENT_DELAY)と記述し、次の視点に移動するまでその場で待機します。
vs.Delay = 4.0と記述し、4秒間待機します。
「vs = routine.addStatement(VC_STATEMENT_VIEW)」と記述し、視点を移動します。
vs.Delay = 4.0と記述し、視点を4秒間かけて移動します。
vs.Viewと記述し、ビューエディタの中から移動したい視点を参照します。
視点がView2になっているため、View02に変更します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
View01に視点が移動する際に、4秒間かけて移動せず、すぐにView01に移動し、8秒間待機していることがわかります。
シミュレーションをリセットします。
View01に4秒間かけて移動するように修正します。
PythonScript_2を開きます。
View01に4秒間移動するソースコードを読み込む前にプログラムが処理されているため、すぐに視点が移動してしまいます。
View01のソースコードの前に遅延を発生させ、ソースコードを読み込む時間を確保します。
26行目と27行目のソースコードをコピーします。
21行目の前に貼り付けます。
「vs.Delay = 4.0」を「0.1」に変更し、0.1秒遅延させます。
コンパイルボタンをクリックします。
シミュレーションを実行します。
View01に約4秒間かけて視点が移動します。
View01で4秒間視点が待機します。
View02に4秒間かけて視点が移動します。
シミュレーションをリセットします。
View03～05の視点のアニメーションを追加します。
PythonScript_2を開きます。
28行目～32行目をコピーし、下の行に3回貼り付けます。
38行目のvs.View = View02 をView03にし、視点をView03に変更します。
44行目のvs.View = View02 をView04にし、視点をView04に変更します。
50行目のvs.View = View02 をView04にし、視点をView05に変更します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
View01に約4秒間かけて視点が移動します。
View01で4秒間視点が待機します。
View02に4秒間かけて視点が移動します。
View02で4秒間視点が待機します。
以降同様にView03～05の視点が移動と待機を繰り返します。
シミュレーションをリセットします。
View01にすぐに視点が移動した後、4秒間待機するよう変更します。
PythonScript_2を開きます。
24行目のvs.Delay = 4.0を0.0に変更します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
View01に視点が移動する際に、すぐにView01に移動し、4秒間待機します。
View02に4秒間かけて視点が移動します。
View02で4秒間視点が待機します。
以降同様にView03～05の視点が移動と待機を繰り返します。
Pythonで作成したカメラの動きをカメラアニメーターで確認します。
[ホーム]-[Camera]-[カメラアニメーター]を選択します。
[カメラアニメーター]ウィンドウを確認すると、カメラの動きが設定されていることがわかります。
録画する時のカメラの視点をPythonで設定する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

RT ToolBox3と連携しよう

RT ToolBox3でティーチングしたプログラムと連携して、ロボットを制御する方法
https://youtu.be/sL0N3gT51bw
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_128.zip

GeminiとRTToolBox3を連携させる方法について説明します。
RTToolBox3で、シミュレーション機能を使用するため、ライセンスが必要です。
ただし、シミュレーションを使用できるライセンスと、使用できないライセンスがあり、注意が必要です。
設定が完了すると、RTToolBox3で設定したプログラムに従って、Gemini上のロボットが動作し、ワークを搬送します。
付属ファイル「RT連携_before.vcmx」を開きます。
ワークを生成するFeeder、搬送先、ロボット、グリッパーがあります。
GeminiとRTToolBox3を連携させ、信号や運動量を送受信することで、ロボットを動作させます。
RTToolBox3を起動します。
画面左上にある[開く]をクリックします。
[ワークスペースを開く]ウィンドウの[参照]をクリックし、付属ファイル[RTToolBox3]を選択します。
[OK]をクリックすることで、[ワークスペースを開く]ウィンドウに、ワークスペースを表示できます。
[ワークスペース]を選択し、[OK]をクリックします。
ワークスペースには、すでにプログラムが設定されています。
Feeder上に、ワークを検出した時、ロボットはワークの位置まで移動し、ワークをつかみます。
ロボットは搬送先に移動し、ワークをはなし、次にワークを検出するまで待機します。
RTToolBox3のシミュレーションを開始します。
画面上側にある[モード]から[シミュレーター]を選択します。
[プロジェクトを選択]ウィンドウで、RC1にチェックがついていることを確認し、[OK]をクリックします。
「GX Simulator3を起動してください」というメッセージが表示されます。
[OK]をクリックします。
今回、GX Simulator3は使用しません。
[3Dモニター]ウィンドウにはロボット、[1:RC1 シミュレーション]ウィンドウには操作盤が表示されます。
[1:RC1 シミュレーション]ウィンドウで[開始]をクリックします。
Geminiの画面を表示します。
RTToolBox3と接続します。
[接続性]タブを開きます。
[接続性]タブが表示されない場合、[ファイル]タブをクリックします。
[オプション]をクリックし、[アドオン]を選択することで、[接続性]タブの表示を設定することができます。
[有効にする]と、[OK]をクリックし、Geminiを再起動することで、[接続性]タブを表示できます。
[接続性]タブを開きます。
RTToolBox3との接続設定を追加します。
[MITSUBISHI ELECTRIC FA]を選択し、右クリックして、[サーバーを接続]を選択することで、接続設定を追加できます。
[MITSUBISHI ELECTRIC FA]に、[サーバー]が追加されたことがわかります。
[MITSUBISHI ELECTRIC FA]を選択した状態で、[サーバー]グループの[サーバーを接続]をクリックすることでも接続設定を追加できます。
[サーバー]をダブルクリックし、名前をRTに変更します。
[接続を編集]ウィンドウでは、接続の詳細を設定できます。
[PC側I/F]は、Geminiの接続先を設定できます。
RTToolBox3を選択します。
[サーバー側ロボット]は、RTToolBox3側のロボットの機種、[シミュレーション側ロボット]は、Gemini側のロボットの機種を定義できます。
[サーバー側ロボット]では、自動的にRV-4FRL-R-SHが選択されています。
[シミュレーション側ロボット]は、RV-4FRLです。
[先頭信号番号・点数設定]は、RTToolBox3で使用する信号の種類と範囲を設定できます。
デフォルトでは、In0から1000点、Out0から1000点分、確保しています。
今回は、デフォルトから変更しません。
[接続をテスト]をクリックし、接続を確認します。
「接続に成功しました」と表示されるため、[OK]をクリックします。
[適用]を選択します。
GeminiとRTToolBox3を接続します。
[接続性コンフィグ]ウィンドウの[RT]の右側にあるアイコンをクリックします。
または、[RT]を選択した状態で、[サーバー]グループの[再接続]をクリックすることでも接続できます。
GeminiとRTToolBox3の信号のペアを作成します。
ペアにすることで、信号の値の変化を連動させることができます。
[RT]の下には[シミュレーションからサーバーへ]と[サーバーからシミュレーションへ]とあります。
ここでは、シミュレーションはGemini、サーバーはRTToolBox3を表しています。
GeminiからRTToolBox3へ送信する信号のペアを作成します。
GeminiからRTToolBox3へ送信する信号は、Feederに設定されたワークを検出するセンサーの信号です。
ワークを検出した場合、信号はオン、検出していない場合、オフです。
[シミュレーションからサーバーへ]を選択し、右クリック、[変数を追加]を選択します。
[変数ペア作成]ウィンドウの左側がGemini、右側がRTToolBox3の信号です。
Gemini側で、[Feeder]を展開し、[BooleanSignal]を選択します。
RTToolBox3側で、[In0]を展開し、[In100]を選択します。
Gemini側と、RTToolBox3側の信号を選択し、[選択済みペア]をクリックすることで、信号のペアを作成できます。
RTToolBox3からGeminiへ送信する信号のペアを作成します。
RTToolBox3からGeminiへ送信する信号は、ロボットにワークのつかむ、はなすを指示する信号と、グリッパーの開閉を指示する信号です。
[接続性コンフィグ]ウィンドウの[RT]の下にある[サーバーからシミュレーションへ]を選択します。
[変数ペア作成]ウィンドウの[グループへの追加]が、[シミュレーションからサーバーへ]に変化したことがわかります。
ロボットには、シグナルマップという連続した番号の信号が設定されています。
シグナルマップを表示するため、チェックボックスにチェックを付けます。
[RV-4FRL]を展開すると、[Inputs]と[Outputs]という名前のシグナルマップが表示されます。
[Outputs]の65番目は、ロボットにワークのつかむ、はなすを指示する信号です。
[Outputs]65を選択します。
RTToolBox3側で、[Out0]を展開し、[Out65]を選択します。
[選択済みペア]をクリックし、信号のペアを作成します。
同様に、グリッパーの開閉を指示する信号を設定するため、Gemini側で[Outputs]100を選択します。
RTToolBox3側は、[Out100]です。
[選択済みペア]をクリックし、信号のペアを作成します。
Geminiのシミュレーションを開始します。
Feederでワークが生成され、ロボットがワークを搬送したことがわかります。
[接続済変数]ウィンドウでは、GeminiとRTToolBox3の信号と、その値を確認できます。
[サーバーからシミュレーションへ]の[サーバー変数]J1からJ6は、ロボットの可動部の運動量です。
ロボットはRTToolBox3から、運動量を受け取り、動作しています。
GeminiとRTToolBox3を連携させる方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

インデックステーブルを使ってみよう(1/2)

インデックステーブルのシグナルに、ロボットから値を送信して、回転を制御する方法（Indexing Table）
https://youtu.be/1S-aI9lrGv8
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_113_p1.zip

インデックステーブルを使用する方法を説明します。
パート1では、インデックステーブルの基本的な動きについて説明します。
eカタログの[タイプ別モデル]-[Robots Workpiece Positioners]-[Visual Components]を展開します。
[Indexing Table]を追加します。
[マニピュレーション]-[インタラクティブ]を選択します。
[Indexing Table]をクリックしたままマウスを動かすと、インデックステーブルが回転します。
このインデックステーブルはシグナルを使用して部品やワークなどの位置決めを行います。
[接続]-[シグナル]を選択します。
インデックステーブルをクリックすると、使用できるシグナルが表示されます。
このインデックステーブルではインデックスシグナルとレディシグナルの2つのシグナルが使用できます。
インデックステーブルを回転させたいときにはインデックスシグナルに値を送信する必要があります。
値が送信されることで、FalseからTrueに変化する時、または、TrueからFalseに変化する時にインデックステーブルは回転します。
インデックステーブルの回転が完了するとレディシグナルに値が格納されます。
レディシグナルを使用して、インデックステーブルの回転量を制御できます。
[コンポーネントプロパティ]ウィンドウを開きます。
[index]の[Relative]では相対値で、[Absolute]では絶対値で、回転を制御することができます。
[IndexAngleOnTrue]はIndexSignalにTrueが入った際に回転する角度を設定でき、[IndexAngleOnFalse]はIndexSignalにFalseが入った際に回転する角度を設定できます。
角度がプラスの場合は反時計回り、マイナスの場合は時計回りに回転します。
[IndexingTime]はインデックステーブルが指定した角度分回転するのにかかる時間を設定できます。
動作を確認するためにロボットを追加します。
今回の動作確認では回転を相対的に制御させるため、[index]を[Relative]にします。
eカタログの[タイプ別モデル]-[Robots]-[Mitsubishi Electric]を展開します。
[RV-13FL]を追加します。
ロボットとインデックステーブルを接続します。
[接続]-[シグナル]を選択します。
ロボットからインデックスシグナルに値を送るため、[Indexing Table]の[IndexSignal]と[RV-13FL]の[出力]を接続します。
出力シグナルは100を使用するため、0をダブルクリックして、100を入力し、Enterキーを押します。
レディシグナルをロボットに送るため、[Indexing Table]の[ReadySignal]と[RV-13FL]の[入力]を接続します。
入力シグナルは101を使用するため、0をダブルクリックして、101を入力し、Enterキーを押します。
ロボットを動かすためにプログラムします。
[接続]-[シグナル]の選択を外します。
[プログラム]タブを開きます。
[マニピュレーション]-[ジョグ]が選択された状態で、ロボットを選択します。
インデックステーブルを回転させるために、ロボットからインデックスシグナルに値を出力する設定をします。
[プログラムエディタ]ウィンドウの[サブプログラム]-[Main]に[セットバイナリ出力ステートメント]を追加します。
[ステートメントプロパティ]ウィンドウの[バイナリ出力ステートメント]に100を入力し、インデックステーブルの出力シグナルを設定します。
[出力値]にチェックを入れて、Trueにします。
インデックステーブルの回転が完了するまでプログラムを待機します。
インデックステーブルの回転が完了したときに、入力シグナルの101にTrueが送信されるため、入力シグナルの101がTrueになるまで待機します。
[プログラムエディタ]ウィンドウの[サブプログラム]-[Main]に[バイナリ入力待機ステートメント]を追加します。
[ステートメントプロパティ]ウィンドウの[入力ポート]を101にします。
[入力値]にチェックを入れて、Trueにします。
[トリガー待機]は、特定の動作などをトリガーとして、処理を実行する場合に使用します。
今回はトリガーで処理を行うため、チェックを入れます。
シミュレーションを実行します。
インデックステーブルが回転し、回転が終了するとプログラムが停止し、シミュレーションも停止します。
インデックステーブルに円柱を追加します。
[ホーム]タブを開きます。
eカタログの[タイプ別モデル]-[Products and Containers]を選択します。
検索ボックスで[Cylinder]を検索します。
[Cylinder]を追加します。
円柱をインデックステーブルにある黒いプレートにスナップします。
円柱を選択します。
[ツール]-[スナップ]を選択します。
インデックステーブルにある任意の黒いプレートの中央を選択します。
[マニピュレーション]-[インタラクティブ]を選択します。
インデックステーブルを選択し、動かすと円柱がインデックステーブルにアタッチされておらずインデックステーブルのみが回転していることが分かります。
シミュレーションをリセットします。
一緒に動くようにするため、円柱をインデックステーブルに取り付けます。
円柱を選択します。
[階層]-[アタッチ]を選択し、インデックステーブルをクリックします。
[出力]ウィンドウを確認すると、「Setting 'Cylinder' parent to 'Link1'.」と記載されアタッチされたことがわかります。
再度、[階層]-[アタッチ]を選択すると青い矢印が表示され、円柱がインデックステーブルに取り付けられたことがわかります。
[階層]-[アタッチ]の選択を外します。
インデックステーブルを選択し、動かすと今度は円柱がインデックステーブルと一緒に回転することが分かります。
シミュレーションをリセットします。
シミュレーションを実行します。
インデックステーブルと円柱が回転します。
インデックステーブルを元の位置に戻すため、ロボットからインデックスシグナルにfalseを出力する設定します。
[プログラム]タブを開きます。
[マニピュレーション]-[ジョグ]が選択された状態で、ロボットを選択します。
現在は、テーブルの回転が終わった後にプログラムが停止しています。
次の処理に移る前に、処理時間に余裕を持たせるため、2秒待機させます。
[遅延ステートメント]を追加します。
[ステートメントプロパティ]ウィンドウの[遅延]に2を入力します。
既にある処理を流用するため、Set OUTとWait INを選択してコピーします。
Delay 2sを選択してペーストします。
ペーストしたSet OUTを選択します。
Falseの角度で回転させるため、出力値のチェックを外し、Falseにします。
インデックステーブルの回転が完了するまでプログラムを待機します。
[プログラムエディタ]ウィンドウの先ほどコピーしたWait INを選択します。
入力値のチェックを外し、Falseにします。
シミュレーションをリセットします。
シミュレーションを実行します。
インデックステーブルが回転し、2秒待機したあと元の位置まで回転し停止します。
相対値で回転を制御して動きを確認しました。
絶対値で回転を制御して動きを確認します。
[ホーム]タブを開きます。
インデックステーブルを選択します。
[コンポーネントプロパティ]ウィンドウの[Index]をAbsoluteに変更します。
シミュレーションをリセットします。
シミュレーションを実行します。
Trueでは[Relative]と同じ位置まで回転しますが、Falseでは[Relative]と異なる位置まで回転します。
[Relative]では[IndexAngleOnTrue]の設定値で移動した位置を基準として[IndexAngleOnFalse]で設定した値だけ回転します。
[Absolute]では初期位置を基準に[IndexAngleOnFalse]で設定した値まで回転します。
[IndexAngleOnFalse]を-300に設定した場合を確認します。
[コンポーネントプロパティ]ウィンドウの[IndexAngleOnFalse]を-300に変更します。
シミュレーションをリセットします。
シミュレーションを実行します。
Trueで60°回転し、Falseで-300°回転します。
初期位置に対して-300°逆回転するので、初めにTrueの値で60°回転した場所と同じ位置に戻ります。
[コンポーネントプロパティ]ウィンドウの[IndexTime]は変更していないので移動距離が増えた分移動速度が早くなったことが分かります。
インデックステーブルの基本的な動きについての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

インデックステーブルを使ってみよう(2/2)

インデックステーブルの回転に合わせて、ロボットが製品をプレースする方法（Indexing Table）
https://youtu.be/nMnbLHGQuBo
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_113_p2.zip

インデックステーブルを使用する方法を説明します。
パート1では、インデックステーブルの基本的な動きについて説明しました。
パート2では、ロボットやコンベヤを使用してインデックステーブルを使用する方法を説明します。
パート1で使用したファイル、もしくは、[Use an Indexing Table - Part1_after.vcmx]をダウンロードし、開きます。
インデックステーブルに置いてある円柱を選択し、削除します。
フィーダーとコンベヤを追加します。
eカタログの[タイプ別モデル]-[Feeders]-[Visual Components]を展開します。
[Basic Feeder]を追加します。
eカタログの[タイプ別モデル]-[Conveyors]-[Visual Components]を展開します。
[Conveyor]を追加します。
[マニピュレーション]-[PnP]を選択します。
コンベヤを選択し、フィーダーに接続します。
コンベヤとフィーダーの幅を調整します。
コンベヤを選択している状態でCtrlキーを押しながらフィーダーを選択します。
[コンポーネントプロパティ]ウィンドウの[ConveyorWidth]を420に変更します。
2つ選択しているのでコンベヤとフィーダーの幅が二つ同時に変更されました。
センサーを追加します。
eカタログの[タイプ別モデル]-[Conveyor Utilities]-[Visual Components]を展開します。
[Conveyor Sensor]を追加します。
[マニピュレーション]-[PnP]を選択された状態で、センサーを選択し、コンベヤに近づけ接続します。
青い矢印が表示され、センサーがコンベヤに接続されたことがわかります。
ロボットがコンベアに届くようにフィーダーとコンベアの位置を調整します。
Ctrlキーを使用して、フィーダーとコンベヤを選択し、位置を調整します。
センサーはコンベヤと接続されているため一緒に移動します。
同様にインデックステーブルの位置を調整します。
センサーの入力信号をロボットに送信させるため、センサーとロボットを接続します。
[接続]-[シグナル]を選択します。
センサーを選択します。
ワークが到達したことをロボットに通知するため、[Conveyor Sensor]の[SensorBooleanSignal]と[RV-13FL]の[入力]を接続します。
入力シグナルは102を使用するため、0をダブルクリックして、102を入力し、Enterキーを押します。
[コンポーネントプロパティ]ウィンドウを開きます。
[On Sensor Action]で[StopPart]を選択します。
[StopPart]は、センサーがワークを検知すると、ワークがセンサーの位置で止まります。
センサーがワークを検知し、ワークが止まり、ロボットが信号を受け取るまでのプログラムを作成します。
[接続]-[シグナル]の選択を外します。
[プログラム]タブを開きます。
[マニピュレーション]-[ジョグ]が選択された状態で、ロボットを選択します。
[プログラムエディタ]ウィンドウの[サブプログラム]-[Main]に既にあるプログラムを全て選択して削除します。
センサーから信号を受け取るプログラムを設定します。
[プログラムエディタ]ウィンドウの[サブプログラム]-[Main]に[バイナリ入力待機ステートメント]を追加します。
[ステートメントプロパティ]の[入力ポート]を先ほど設定した102にします。
[入力値]にチェックを入れて、Trueにします。
[トリガー待機]は、特定の動作などをトリガーとして、処理を実行する場合に使用します。
今回はトリガーで処理を行わないため、チェック無しのままにします。
ワークがセンサーに到着すると、シミュレータが停止するプログラムを設定します。
[プログラムエディタ]ウィンドウの[サブプログラム]-[Main]に[停止ステートメント]を追加します。
シミュレーションを実行します。
ワークがセンサーに到着したのでシミュレーションが停止します。
ロボットがワークまで移動し、ワークを持ち上げるまでのプログラムを設定します。
[マニピュレーション]-[ジョグ]が選択されていることを確認します。
ロボット先端のピンク色の部分を選択したまま、ワーク上面の中心にロボットをスナップします。
この状態で、[直線補間ステートメント]を追加します。
[直線補間ステートメント]は、ロボットの位置を記録し、最短距離で動かすことができます。
ワークを掴むプログラムを設定します。
ロボットを選択します。
[コンポーネントプロパティ]ウィンドウの[既定]タブ-[アクション設定]を開きます。
シグナルアクションの[出力]を1にして、Trueとfalseが出力された場合の動きを確認します。
出力1がTrueの場合は[つかむ]、Falseの場合は[リリース]がデフォルトで選択されています。
[セットバイナリ出力ステートメント]を追加します。
[ステートメントプロパティ]の[バイナリ出力ステートメント]をシグナルアクションの出力1にします。
[出力値]にチェックを入れて、Trueにすることでワークを掴みます。
[マニピュレーション]-[ジョグ]が選択されている状態でロボットを選択し、+Z軸方向に移動します。
[直線補間ステートメント]を追加します。
[各軸補間ステートメント]を追加します。
[各軸補間ステートメント]は、ロボットの位置を記録し、ジョイントの値を補間して動かすことができます。
[各軸補間ステートメント]を上から2番目の位置に移動し、[停止ステートメント]を一番最後に移動します。
ロボットはセンサーから信号を受け取った後、ワークの位置まで移動し、ワークを持ち上げ、シミュレーションが停止します。
シミュレーションをリセットします。
シミュレーションを実行します。
ワークがセンサーに到達し、ロボットがワークを持ち上げ、シミュレーションが停止します。
ワークをインデックステーブルまで移動させるプログラムを設定します。
[マニピュレーション]-[ジョグ]が選択されている状態でロボットを選択し、ピンクの丸をドラッグしてインデックステーブルの黒いプレートの近くまで移動します。
Shiftキーを押しながらワークの底にマウスカーソルを合わせると、整列機能で底面を選択できます。
ドラッグしながらワークを黒いプレートの上に配置します。
escキーを押し、整列を終了します。
[直線補間ステートメント]を追加します。
ワークを離すプログラムを設定します。
[セットバイナリ出力ステートメント]を追加します。
[ステートメントプロパティ]の[バイナリ出力ステートメント]をシグナルアクションの出力1にします。
[出力値]にチェックは入れず、Falseにすることでワークを離します。
[マニピュレーション]-[ジョグ]が選択されている状態でロボットを選択し、+Z軸方向に移動します。
[直線補間ステートメント]を追加します。
[各軸補間ステートメント]を追加します。
[各軸補間ステートメント]を[停止ステートメント]の位置に移動し、[停止ステートメント]を一番最後に移動します。
ロボットは持ち上げたワークをインデックステーブルまで移動させ、ワークを離し、シミュレーションが停止します。
インデックステーブルを回転させるために、ロボットからインデックスシグナルに値を出力する設定をします。
[セットバイナリ出力ステートメント]を追加します。
[ステートメントプロパティ]の[バイナリ出力ステートメント]に100を入力し、インデックステーブルの出力シグナルを設定します。
[出力値]にチェックを入れて、Trueにします。
インデックステーブルの回転が完了するまでプログラムを待機します。
[バイナリ入力待機ステートメント]を追加します。
[ステートメントプロパティ]の[入力ポート]を101にします。
[入力値]にチェックを入れて、Trueにします。
[トリガー待機]は、特定の動作などをトリガーとして、処理を実行する場合に使用します。
今回はトリガーで処理を行うため、チェックを入れます。
インデックステーブルの動きが分かりやすいように[停止ステートメント]の位置はこのままにします。
シミュレーションをリセットします。
シミュレーションを実行します。
ワークがセンサーまで到達すると、ロボットがワークを持ち上げ、インデックステーブルまでワークを配置し、シミュレーションが停止します。
インデックステーブルの動きを確認するため、再度シミュレーションを実行します。
インデックステーブルが回転するのを確認し、シミュレーションを一時停止します。
動きを確認できたため[停止ステートメント]を削除します。
ロボットが一連の動作を繰り返すプログラムを設定します。
シミュレーションをリセットします。
[プログラムエディタ]ウィンドウの[サブプログラム]にある[シーケンスをコピー]をクリックします。
作成したメインシーケンスをコピーできます。
名前を[PickPlacePartIndex]に変更します。
[Main]を選択します。
プログラムを全て削除します。
[コールシーケンスステートメント]を追加します。
[コールシーケンスステートメント]は、ロボットプログラムのサブルーチンを呼び出すことができます。
[ステートメントプロパティ]ウィンドウの[Routine]で呼び出したいサブルーチンを選択します。
デフォルトで、[PickPlacePartIndex]が選択されていることを確認します。
シミュレーションをリセットします。
ループ処理を設定します。
ロボットを選択します。
[コンポーネントプロパティ]ウィンドウの[Executor]タブを開きます。
ルーピングにチェックを入れます。
シミュレーションを実行します。
ロボットがワークを持ち上げ、インデックステーブルまでワークを運ぶ動作を繰り返していますが、インデックステーブルは1回しか回転しません。
シミュレーションを一時停止します。
インデックステーブルの設定を確認します。
インデックステーブルを選択します。
[コンポーネントプロパティ]ウィンドウの[Index]がAbsoluteで絶対値の制御になっています。
回転後の角度を示している[EJ1]の項目を確認すると、インデックステーブルが1回回転したため、0から60になっています。
絶対値の制御では初期値を基準で回転するため、[EJ1]には[IndexAngleOnTrue]と同じ60が入力され続け、回転しません。
[Index]をRelativeにし、相対値の制御に変更します。
シミュレーションをリセットします。
シミュレーションを実行します。
ロボットがワークを持ち上げ、インデックステーブルまでワークを運び、インデックステーブルが回転する動作を繰り返します。
[コンポーネントプロパティ]ウィンドウを確認すると、[EJ1]の値が、60°ずつ増えていることがわかります。
ロボットやコンベヤを使用してインデックステーブルを使用する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

オーバレイメニューを使用して、ステートメントを追加しよう

パイソンスクリプト（Python）の外部ファイルを使用して、ロボットのオーバレイメニュー(重ねて表示するメニュー)とステートメントを追加する方法
https://youtu.be/15k5WEFTfME
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_161.zip

オーバレイメニューを使用して、ステートメントを追加する方法を説明します。
オーバレイメニューとは、表示されているコンテンツの上に重ねて表示されるメニューのことです。
作業を中断せずに追加のオプションや機能にアクセスできます。
ロボットを配置します。
eカタログの[タイプ別モデル]-[Robots]-[Mitsubishi Electric]を開きます。
[RV-13FL]を追加します。
ロボットの横にオーバレイメニューを表示します。
[プログラム]タブを開きます。
3Dワールド上で右クリックし、[表示]-[オーバレイ講座に関するメニュー]を選択します。
各軸補間ステートメントと直線補間ステートメントのボタンが表示されていることがわかります。
[TeachTraceGraspOverlay]をダウンロードします。
Pythonスクリプトを使用して、オーバレイメニューにボタンを追加します。
[ドキュメント]-[MITSUBISHI]-[Gemini]-[1.48]-[My Commands]を開きます。
[My Commands]に[TeachTraceGraspOverlay]をドラッグ＆ドロップします。
Pythonスクリプトを確認します。
[TeachTraceGraspOverlay]-[__init__.py]をメモ帳などのテキストエディタで開きます
[__init__.py]は、ボタンを設定しています。
12行目はコマンド名のリストを定義しています。
14行目はアイコンの説明を設定しています。
[teachGrasp.py]を開きます。
[teachGrasp.py]は、ロボットを移動し、物を掴む動作を設定しています。
13行目と14行目は、物を掴む動作を設定しています。
ステートメントの出力ポートを1、値をTrueに設定しています。
19行目は、物を掴んだ後、持ち上げる動作を設定しています。
ロボットの位置を-Z軸方向に100.0mm移動させています。
[teachTraceOff.py]を開きます。
[teachTraceOff.py]は、移動した時の軌跡をオフにします。
10行目と11行目ではステートメントの出力ポートを17、値をFalseに設定しています。
[teachTraceOn.py]を開きます。
[teachTraceOn.py]は、移動した時の軌跡をオンにします。
13行目と14行目はステートメントの出力ポートを17に設定し、その値をTrueに設定しています。
出力ポートを17に設定することで、ロボットのパスが赤色でトレースされます。
My Commandsに追加されたデータは、Geminiを再起動しないと反映されないため、一旦保存し、再起動します。
[プログラム]タブを開きます。
ロボットを選択します。
3Dワールド上で右クリックし、[表示]-[オーバレイ講座に関するメニュー]を選択します。
Trace On、Trace Off、Graspボタンが表示されます。
ボタンを使用して、ロボットで箱をピックする動作を設定します。
[ホーム]タブを開きます。
箱を配置します。
eカタログの[タイプ別モデル]-[Basic Shapes]を選択します。
[Block Geo]を追加します。
[コンポーネントプロパティ]ウィンドウの[Height_Z]を300、[Length_X]を150、[Width_Y]を400にします。
[プログラム]タブを開きます。
[マニピュレーション]-[ジョグ]が選択された状態で、ロボットの先端を選択し、箱の上面に移動します。
Trace Onを使用して、ロボットのパスを赤色でトレースします。
[Trace On]を選択します。
[プログラムエディタ]ウィンドウを確認すると、ステートメントが追加されています。
Graspを使用して、ロボットで箱を掴みます。
[Grasp]を選択します。
[プログラムエディタ]ウィンドウを確認すると、4つのステートメントが追加されています。
青色の四角をドラッグし、ロボットを平行移動します。
各軸補間ステートメントを使用してロボットを移動します。
[各軸補間ステートメント]を選択します。
[プログラムエディタ]ウィンドウを確認すると、ステートメントが追加されています。
シミュレーションをリセットします。
シミュレーションを実行すると、ロボットが箱をピックアップして移動します。
[プログラムエディタ]ウィンドウを使用せず、ロボットのステートメントを追加させることができます。
オーバレイメニューを使用して、ステートメントを追加する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

プロセスハンドラを使用して、ロボットを制御しよう

プロセスハンドラーとパイソンスクリプト（Python）を使用して、ロボットを制御する方法
https://youtu.be/wuasutkTJVo
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_164.zip

プロセスハンドラを使用して、ロボットを制御する方法を説明します。
プロセスハンドラは、ロボットに関連したプロセスを定義できる機能です。
プロセスハンドラには、ロボットの制御に便利なメソッドが含まれています。
ロボットプログラムにプロセスステートメントを追加し、プロセスハンドラを呼び出すことで、定義したプロセスを実行できます。
ロボットを配置します。
eカタログの[タイプ別モデル]-[Robots]-[Mitsubishi Electric]を展開します。
[RV-13FL]を配置します。
プロセスハンドラーを作成し、パイソンスクリプトを記述します。
[モデリング]タブを開きます。
[動作設定]-[ビヘイビア]-[その他]-[プロセスハンドラー]を作成します。
ロボットのステートメントでプロセスハンドラーを参照すると、ロボットが各位置に移動するように設定します。
from vcPythonProcessHandler import *は、ロボットやロボットに関連する機器を制御するメソッドを呼び出します。
vcPythonProcessHandlerの詳細は、ヘルプで確認できます。
[ヘルプ]タブを開きます。
[ヘルプと参照]-[パイソンAPI]を選択します。
コンテンツの[vcPythonProcessHandler]を選択すると、詳細が確認できます。
OnSignal関数は不要なため、削除します。
def OnStatementAdd():と記述し、ロボットプログラムにこのプロセスハンドラを参照するステートメントが追加されたときに処理します。
引数はstatementにします。
ロボットを90度ずつ回転します。
for i in range(5):と記述し、0～4をiという変数に代入し、ループ処理します。
pos = statement.createPosition("PP")と記述し、PPという名前の位置を作成します。
mtx = pos.PositionInWorldと記述し、ワールド座標系を基準にします。
mtx.translateAbs(1200,0,1000)と記述し、位置を絶対座標でX方向に1200mm、Z方向に1000mm移動させます。
mtx.rotateAbsZ(i*90)と記述し、Z軸を中心に90度回転させます。
iには0～4までの数値が入るため、0度、90度、180度、270度、360度の位置まで回転します。
pos.PositionInWorld = mtxと記述し、移動した後の位置を現在の位置として更新します。
シミュレーションを実行すると、設定した位置に移動するようにします。
def OnStatementExecute():は、シミュレーションを実行したときに処理します。
第一引数はexecutor、第二引数はstatementがデフォルトで設定されています。
passを削除します。
for pos in statement.Positions:と記述し、ステートメントに含まれている位置をposという変数に代入し、ループ処理します。
executor.Controller.moveTo(pos.PositionInWorld)と記述し、ロボットを指定した位置まで移動します。
コンパイルボタンをクリックします。
[モデリング]タブを開きます。
[コンポーネントグラフ]ウィンドウの[Executor]を選択します。
ロボットエグゼキューターにプロセスハンドラーを設定します。
ロボットエグゼキューターを使用することで、ロボットプログラムの読み出し、書き込み、実行ができます。
[プロパティ]ウィンドウの[ステートメントハンドラー]で[PythonProcessHandler]を選択します。
ロボットプログラムにステートメントを追加して、プロセスハンドラを実行します。
Pythonを使用して、ロボットプログラムにステートメントを追加します。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
Onsignal関数とOnRun関数は不要なため、削除します。
comp = getComponent()と記述し、コンポーネントの情報を取得します。
rx = comp.findBehavioursByTypeと記述し、指定したタイプのビヘイビアを取得します。
rRobotExecutorと記述し、ロボットのエグゼキューターを全て取得します。
今回は、ロボットのエグゼキューターが1つしかないため、0番目のエグゼキューターを取得します。
rx.Program.MainRoutine.addStatementと記述し、ロボットのメインルーチンにステートメントを追加します。
プロセスハンドラをステートメントに設定するためには、プロセスステートメントを追加する必要があるため、Processと記述します。
ロボットの動作設定については、関連動画として「ロボットプログラムをPythonで記述してみよう(1/2)」があります。是非ご覧ください。
コンパイルボタンをクリックします。
プロセスハンドラをステートメントに設定します。
[プログラム]タブを開きます。
[サブプログラム]ウィンドウを確認すると、プロセスステートメントが追加されていることがわかります。
プロセスステートメントをクリックします。
[ステートメントプロパティ]ウィンドウの[Process]で[PythonProcessHandler]を選択します。
3DワールドにPPという名前の位置が表示されます。
名前が表示されない場合は、3Dワールドツールバーの[ロボットポジション]にチェックを入れると、表示されます。
シミュレーションを実行します。
ロボットがX方向に1200mm、Z方向に1000mm移動した後、回転します。
シミュレーションをリセットします。
プロセスハンドラを編集します。
[モデリング]タブを開きます。
[PythonProcessHandler]を開きます。
全ての位置がPPという名前になっているため、名前を変更します。
pos.Name += str(i)と記述し、名前の後ろに数字を付け足します。
iには0～4までの数値が入るため、PP0～PP4の名前になります。
getApplication().render()を関数の最後に記述し、3Dワールドを再描画することで、3Dワールド上に名前や位置を表示します。
現在の位置をクリアします。
def OnStatementRemove():と記述し、プロセスステートメント内でプロセスハンドラの参照が削除されたときに処理します。
引数をstatementにします。
for pos in statement.Positions:と記述し、posという変数にステートメント内の位置を代入し、ループ処理します。
ループ中にリストの要素が減ってしまうと、リストの要素の数が変わるため、次に削除するはずの要素が変わってしまいます。
そのため、list()を使用し、リストのコピーを作成することで、元のリストが変わっても、影響を受けないようにします。
statement.deletePosition(pos)と記述し、ステートメント内の位置を削除します。
getApplication().render()と記述し、3Dワールドを再描画することで、3Dワールド上の名前の表示を削除します。
コンパイルボタンをクリックします。
名前の表示を変更するため、プロセスハンドラを再読み込みします。
[プログラム]タブを開きます。
プロセスステートメントを選択します。
[ステートメントプロパティ]ウィンドウの[Process]で[Null]を選択します。
[ステートメントプロパティ]ウィンドウの[Process]で[PythonProcessHandler]を選択します。
3Dワールドを確認すると、位置の名前が変更されていることがわかります。
プロセスステートメントに項目を追加します。
各位置のプロパティにスキップのチェック項目を追加し、チェックが入っている場合は、その位置への移動をスキップします。
[モデリング]タブを開きます。
[PythonProcessHandler]を開きます。
def OnStatementModified():と記述し、ステートメントが変更されたときに処理します。
引数をstatementにします。
for pos in statement.Positions:と記述し、posという変数にステートメント内の位置を代入し、ループ処理します。
skip = pos.getProperty("Skip")と記述し、Skipという名前のプロパティを取得します。
if not skip:pos.createProperty()と記述し、Skipという名前がプロパティにないとき、プロパティを作成します。
ブーリアン型のSkipという名前の項目を作成するため、VC_BOOLEAN、Skipと記述します。
スキップにチェックが入っていない位置に移動するため、OnStatementExecute関数にif pos.Skip == False:と記述します。
コンパイルボタンをクリックします。
[プログラム]タブを開きます。
PP0を選択します。
ステートメントを変更すると、[ステートメントプロパティ]ウィンドウにSkipが表示されます。
[Statement]のToolで[Tool1]を選択すると、Skipが表示されたことがわかります。
Skipにチェックを入れます。
シミュレーションをリセットします。
シミュレーションを実行します。
ロボットがPP0の位置をスキップし、PP1からPP4まで移動することがわかります。
説明は以上となりますが、ファイルを保存する場合は、パイソンスクリプトのソースコードをOnRun関数に入れてください。
OnRun関数に入れずにファイルを保存して再度開くと、コードが実行されますが、MainRoutineを即座に読み取ることができずエラーが発生します。
そのため、OnRun関数に入れて、ファイルを読み込む際にコードをすぐに実行しないことで、エラーを回避できます。
ファイルを再度開く際は、OnRun関数を外すと、PROCESS PR2が追加されるため、削除してください。
また、シミュレーションを実行する前に、[ステートメントプロパティ]でToolなどのステートメントを変更してください。
OnStatementModified関数は、ステートメントが変更されたときに処理されるため、ステートメントを変更しないとSkipが表示されず、エラーが発生します。
プロセスハンドラを使用して、ロボットを制御する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットが届く範囲を確認しよう(1/5)

ロボットとポジショナをインタフェース接続して、ロボットがポジショナに届く範囲を確認する方法
https://youtu.be/OpUY6nukPGg
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_158_p1.zip

ロボットが届く範囲を確認する方法を説明します。
パート1では、ロボットとポジショナを配置し、ロボットがポジショナに届くか確認します。
ポジショナーとロボットを配置します。
eカタログの[タイプ別モデル]-[Robot Workpiece Positioner]-[Visual Components]を開きます。
[Positioner - 2 Axis]をダブルクリックし、原点に配置します。
[コンポーネントプロパティ]ウィンドウの[Options]タブを開きます。
[ScaleSize]を0.6にします。
eカタログの[タイプ別モデル]-[Robots]-[Mitsubishi Electric]を開きます。
[RV-13FL]を配置します。
[マニピュレーション]-[PnP]が選択された状態で、3Dワールドの青い円をドラッグし、180度回転します。
表示される円弧の近くにマウスカーソルを置き、180度になるまで5度ずつ回転します。
[コンポーネントプロパティ]ウィンドウのRzが[-180]であることを確認します。
eカタログの[タイプ別モデル]-[Robot Tools]-[Lincoln Electric]を開きます。
[Welding Torch]を追加し、ロボットの先端に取り付けます。
溶接パーツのCADファイルをインポートします。
[WeldPart.FBX]をダウンロードします。
[インポート]-[ジオメトリ]を選択します。
[WeldPart.FBX]を選択し、開きます。
Geminiのマテリアルタイプを適用したいため、[モデルをインポート]ウィンドウの[含める]-[マテリアル]のチェックを外してください。
[インポート]をクリックします。
溶接パーツが選択された状態で、[コンポーネントプロパティ]ウィンドウの[マテリアル]から[steel]を選択します。
[階層]-[アタッチ]を選択し、溶接パーツをポジショナーのテーブルに取り付けます。
[ツール]-[スナップ]を選択し、溶接パーツをポジショナーのテーブルの上に配置します。
ポジショナーのテーブルの中心に移動します。
溶接パーツをテーブルの中心にスナップしましたが、中央に配置されていないことが分かります。
溶接パーツの端がテーブルの中心と一致しているため、溶接パーツの中心、つまり、溶接パーツのY軸の中心とテーブルの中心を一致させます。
[ツール]-[測定]を選択し、溶接パーツのY軸の長さを確認します。
溶接パーツのX軸のエッジと対角線上のY軸の頂点を選択すると、距離が280mmであることが分かります。
280mmを2で割ると140mmになるため、溶接パーツをY軸方向に-140mm移動します。
[マニピュレーション]-[移動]を選択し、3Dワールドで緑色のY軸矢印を移動して中央に配置するか、[コンポーネントプロパティ]ウィンドウのYに-140と入力します。
ポジショナとロボットを接続するためのインターフェースを設定します。
3Dワールドツールバーの[全て]を選択し、画面上に全てのコンポーネントを表示します。
ロボットを選択します。
[接続]-[インターフェース]を選択します。
3Dワールドの[Connect Workpiece Positioner]を[RobotInterface]までドラック＆ドロップするとインターフェースが接続されます。
[接続]-[インターフェース]を選択し、ビューを無効にします。
ロボットをポジショナと一列に配置します。
[マニピュレーション]-[移動]を選択します。
ロボットを選択します。
3Dワールドで緑色のY軸に沿って移動するか、[コンポーネントプロパティ]ウィンドウの[Y]をクリックし 、Yの値を「0」に設定します。
[プログラム]タブを開きます。
[マニピュレーション]-[ジョグ]を選択します。
ビューセレクタの[F]をクリックし、正面を表示します。
3Dワールドツールバーの[全て]を選択し、画面上に全てのコンポーネントを表示します。
[ジョグ]ウィンドウの座標について説明します。
[ジョグ]ウィンドウ-[座標]-[ワールド]を選択します。
ロボットの先端のJ5がハイライトされています。
カメラを動かすと、ビューポートの左上隅に表示される原点の座標と、J5の座標が一致します。
ビューセレクタの[F]をクリックし、正面を表示します。
[ジョグ]ウィンドウ-[座標]-[親]を選択します。
座標は、3Dワールドの親コンポーネントであるロボットの原点に基づいています。
ビューセレクタの[F]をクリックし、正面を表示します。
[マニピュレーション]-[移動]を選択します。
[コンポーネントプロパティ]ウィンドウのRzに[90]と入力し、ロボットを90度回転します。
[マニピュレーション]-[ジョグ]を選択します。
[ジョグ]ウィンドウ-[座標]で[ワールド]と[親]の選択を切り替えると、座標の違いがわかりやすくなります。
[マニピュレーション]-[移動]を選択します。
[コンポーネントプロパティ]ウィンドウのRzに[-180]と入力し、ロボットを元の位置に戻します。
[マニピュレーション]-[ジョグ]を選択します。
[ジョグ]ウィンドウ-[座標]-[オブジェクト]を選択します。
座標は、選択しているコンポーネントの原点に基づいています。
溶接トーチを選択します。
[ジョグ]ウィンドウの[ワールド]を選択します。
緑色の Y 軸の四角形を選択して移動し、ロボットが届くかを確認できます。
また、溶接パーツに届くかも確認できます。
ロボットとポジショナのインターフェースを既に接続しているため、溶接パーツを配置したテーブルの角度をロボットで制御できます。
[ジョグ]ウィンドウ-[Positioner - 2 Axis]-[Tilt]に45と入力し、傾斜角度を 45 度に設定します。
[ジョグ]ウィンドウ-[Positioner - 2 Axis]-[Roll]に90と入力し、ポジショナーのテーブルを90度回転させます。
[ジョグ]ウィンドウ-[座標]-[ツール]-[TCP]を選択します。
マウスの右ボタンをクリックしたまま、溶接パーツの角に金属接合部が見えるようにカメラを回転させます。
後からこのアングルにすぐに戻れるように、カメラアングルを保存します。
3Dワールドツールバーの[ビューエディタ]を選択します。
緑色のプラスを選択すると、現状のビューがリストに追加されます。
ビューセレクタの[F]をクリックし、正面を表示します。
3Dワールドツールバーの[全て]を選択し、画面上に全てのコンポーネントを表示します。
先ほど保存したビューを再度表示するには、3Dワールドツールバーの[ビューエディタ]のView1を選択します。
[ツール]-[スナップ]を選択し、溶接トーチの位置を変更します。
溶接トーチを溶接パーツの角に合わせます。
溶接パーツの角に合わせると、溶接トーチがパーツに干渉する場合があります。
[TCPスナップ]ウィンドウの[オリエンテーションを設定]にチェックを入れ、二等分線を選択することで、干渉せずに角を選択できます。
ロボットとポジショナー全体が3Dワールドに表示されるようにカメラのアングルを調整します。
カメラアングルを保存します。
3Dワールドツールバーの[ビューエディタ]を選択します。
緑色のプラスを選択すると、ビューがリストに追加されます。
溶接トーチのY軸を回転させると、溶接トーチが溶接パーツの角に届いています。
現在の位置を保存します。
シミュレーションコントロールの歯車を選択します。
状態の保存を選択すると、現在の位置とジョグのツールが保存されます。
ロボットとポジショナを配置し、ロボットがポジショナに届くか確認する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットが届く範囲を確認しよう(2/5)

ロボットの可動域を可視化し、ポジショナに届く範囲を確認する方法
https://youtu.be/7dzVuoVMVq0
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_158_p2.zip

ロボットが必要な位置に届くか確認する方法を説明します。
パート1では、ロボットとポジショナを配置し、ロボットがポジショナに届くか確認しました。
パート2では、ロボットがポジショナに届く範囲を可視化します。
パート1で使用したファイル、もしくは、[Robot Reachability Part1_after.vcmx]をダウンロードし、開きます。
[プログラム]タブを開きます。
ロボットを選択します。
テーブルを回転させて、溶接パーツのエッジに届くかを確認します。
マウスの左ボタンをクリックしたまま、緑色のY軸に沿って90度回転させるか、[ジョグ]ウィンドウの[Positioner - 2 Axis]-[Roll]に0と入力します。
ズームインします。
溶接トーチの中心点を溶接パーツのエッジに移動します。
ロボットの角度を変更し、溶接トーチが届くか確認します。
ズームアウトします。
[リミット]-[色のハイライト]を選択し、溶接トーチが届かないときに中心点を赤色で表示します。
溶接トーチのY軸を回転させると、溶接トーチが溶接パーツの角に届いています。
溶接トーチの中心点を溶接パーツの中央のエッジに移動します。
溶接トーチのY軸を回転させると、J5が約-55度を超えるとき、[ジョグ]ウィンドウのJ5が赤く表示され、届かないことがわかります。
溶接トーチが届く範囲を確認します。
溶接トーチの中心点を動かすと、感嘆符が表示された箇所で溶接トーチの中心点が移動できなくなるため、届かないことがわかります。
ロボットの高さを上げると、溶接トーチが届く範囲を広げることができます。
[マニピュレーション]-[移動]を選択します。
ロボットを選択します。
青色の矢印を+Z軸方向に移動するか、[コンポーネントプロパティ]ウィンドウのZに400と入力します。
3Dワールドツールバーの[ビューエディタ]のView2を選択します。
[マニピュレーション]-[ジョグ]を選択します。
溶接トーチの中心点を動かすと、先ほどよりも届く範囲が広がったことがわかります。
ロボットの下に台座を配置します。
[ホーム]タブを開きます。
eカタログの[タイプ別モデル]-[Robot Pedestals]-[Visual Components]を開きます。
[Simple Robot Pedestal]を3Dワールドにドラッグ＆ドロップし追加します。
[コンポーネントプロパティ]ウィンドウのHに[400]と入力し、台座の高さを400ｍｍにします。
Wに[500]と入力し、台座の幅を500mmにします。
[マニピュレーション]-[PnP]が選択された状態で、ロボットの下に配置します。
[プログラム]タブを開きます。
溶接パーツの反対側に溶接パーツが届くか確認します。
溶接トーチの中心点を溶接パーツのロボット側の端に移動します。
溶接トーチのY軸を回転させると、溶接トーチが溶接パーツの角に届いています。
溶接トーチが届く範囲を可視化します。
ロボットの向きを変更します。
[ジョグ]ウィンドウを開きます。
J3以外を0にします。
J3を90にします。
ロボットを選択します。
[コンポーネントプロパティ]ウィンドウを開きます。
[WorkSpace]タブの[Profile]を選択します。
ビューセレクタの[F]をクリックし、正面を表示します。
3Dワールドツールバーの[全て]を選択し、画面上に全てのコンポーネントを表示します。
3Dワールドツールバーの[正射]を選択し、正投影表示をONにします。
現在の位置を保存します。
シミュレーションコントロールの歯車を選択します。
状態の保存を選択すると、現在の位置とジョグのツールが保存されます。
[ホーム]タブを開きます。
[マニピュレーション]-[移動]を選択します。
ポジショナーを選択します。
赤色の矢印を選択し、-X軸方向に移動します。
[マニピュレーション]-[PnP]を選択します。
溶接トーチを選択します。
-X軸方向に移動します。
ロボットのJ5の中心点が届く範囲を確認します。
[プログラム]タブを開きます。
[リミット]-[リミットで停止]を選択し、ロボットが届かない場合、それ以上動かないよう制限します。
ロボットを選択します。
ロボットのアームを動かすと、ロボットが線に沿って動き、ロボットのJ5の中心点が届く範囲の限界を可視化できていることがわかります。
シミュレーションをリセットします。
[リミット]-[リミットで停止]のチェックを外し、ロボットが可動域を超えても動かせるようにします。
ロボットを動かすと、可動域を超えたジョイントが赤色で表示されます。
[リミット]-[メッセージパネル出力リミット]を選択し、ロボットが可動域を超えた場合、[出力]ウィンドウにメッセージを表示します。
可動域でロボットを移動します。
ロボットの中心点を選択し、移動します。
[プログラムエディタ]-[各軸補間ステートメント]を追加します。
[各軸補間ステートメント]は、ロボットの位置を記録し、ジョイントの値を補間して動かすことができます。
ロボットの中心点を選択し、移動します。
[プログラムエディタ]-[各軸補間ステートメント]を追加します。
ロボットの中心点を選択し、移動します。
[プログラムエディタ]-[各軸補間ステートメント]を追加します。
3Dワールドツールバーの[フレームタイプ]-[ロボットポジション]を選択し、追加したポイントを表示します。
シミュレーションをリセットします。
シミュレーションを実行します。
ロボットが3つのポイント間を移動していることがわかります。
シミュレーションをリセットします。
[マニピュレーション]-[移動]を選択します。
P3 を選択します。
可動域の外にP3を移動します。
ロボットがP3に届かないため、中心点は黄色で表示されています。
シミュレーションをリセットします。
シミュレーションを実行します。
ロボットはP3に届かないため、P2で停止していることがわかります。
[出力]ウィンドウを確認すると、位置はロボットの手の届かないところにありますと表示されています。
シミュレーションをリセットします。
[ホーム]タブを開きます。
ポジショナーを選択します。
赤色の矢印を+X軸方向に移動するか、[コンポーネントプロパティ]ウィンドウのXに0を入力し、原点に戻します。
[マニピュレーション]-[PnP]を選択します。
溶接トーチを選択します。
+X軸方向に移動し、ロボットの先端に取り付けます。
3Dワールドツールバーの[正射]を選択し、正投影表示をOFFにします。
[プログラム]タブを開きます。
[マニピュレーション]-[ジョグ]を選択します。
ロボットを選択します。
[コンポーネントプロパティ]ウィンドウの[WorkSpace]タブの[Profile]のチェックを外します。
[Envelope]を選択します。
[ジョグ]ウィンドウを選択します。
3Dワールドに球体が表示され、ロボットの可動域を3次元で確認できます。
球体内にポジショナがあるため、ロボットが届くことがわかります。
[リミット]-[リミットで停止]を選択し、ロボットの動きのリミットも併せて確認できます。
現在の位置を保存します。
シミュレーションコントロールの歯車を選択します。
状態の保存を選択すると、現在の位置とジョグのツールが保存されます。
ロボットがポジショナに届く範囲を可視化する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットが届く範囲を確認しよう(3/5)

ロボットのジョイントを動かして、ロボットがポジショナに届く範囲を確認する方法
https://youtu.be/qgO6zuxWHrQ
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_158_p3.zip

ロボットが届く範囲を確認する方法を説明します。
パート2では、ロボットがポジショナに届く範囲を可視化しました。
パート3では、ロボットのジョイントについて説明します。
[Robot Reachability Part3_before.vcmx]をダウンロードし、開きます。
3Dワールドにロボット1台とポジショナ2台があります。
ポジショナにはそれぞれ溶接パーツが配置されています。
ロボットのジョイントを確認します。
[プログラム]タブを開きます。
[リミット]-[リミットで停止]のチェックを外し、ロボットが可動域を超えても動かせるようにします。
[マニピュレーション]-[ジョグ]が選択された状態で、ロボットを選択します。
[ジョグ]ウィンドウを確認すると、ジョイントが6つあることがわかります。
外部のジョイントとして、ポジショナが2つ接続されています。
J1のスライダーを左右に動かすと、J1が動きます。
同様に、J2以降もスライダーを動かすと、ジョイントがそれぞれ動きます。
数値をダブルクリックして入力すると、指定した数値でジョイントを動かすことができます。
J1には190度から-190度までの制限が設定されています。
J1のスライダーを左右の最大限まで移動すると、190度から-190度まで動かせることがわかります。
シミュレーションをリセットし、初期位置に戻します。
ロボットのモーションステートメントを2つ設定し、ジョイントが制限を超えた場合、どのように表示されるか確認します。
[ジョグ]ウィンドウの[ツール]で[TCP]を選択します。
ツールの[TCP]が選択された状態を保存します。
シミュレーションコントロールの歯車を選択します。
状態の保存を選択すると、現在の位置とジョグのツールが保存されます。
[ツール]-[スナップ]を選択し、溶接トーチの位置を変更します。
溶接トーチを溶接パーツの内側の角に合わせます。
溶接パーツの角に合わせると、溶接トーチがパーツに干渉する場合があります。
[TCPスナップ]ウィンドウの[オリエンテーションを設定]にチェックを入れ、二等分線を選択することで、干渉せずに角を選択できます。
[プログラムエディタ]ウィンドウの[各軸補間ステートメント]を追加します。
[ツール]-[スナップ]を選択し、溶接トーチの位置を変更します。
溶接トーチを溶接パーツの反対側の角に合わせます。
[直線補間ステートメント]を追加します。
[直線補間ステートメント]は、ロボットの位置を記録し、最短距離で動かすことができます。
[ステートメントプロパティ]ウィンドウの[MaxSpeed]でジョイントの最大速度を指定します。
デフォルト値は早すぎるため、100mm/sにします。
[PTP P1]を選択します。
同様に、[ステートメントプロパティ]ウィンドウの[JointSpeed]でジョイントの最大速度を50％にします。
シミュレーションをリセットします。
[リミット]-[色のハイライト]を選択し、溶接トーチが届かないときに中心点を赤色で表示します。
[ジョグ]ウィンドウを開きます。
シミュレーションを実行すると、ロボットがP1からP2に向かって移動します。
[ジョグ]ウィンドウを確認すると、J3が赤くハイライトされています。
P2に向かう途中で、J3の可動域が制限を超えていることがわかります。
J3のスライダー上にマウスオーバーすると、Limitsが-10度から157.5度になっているため、現在の数値では制限を超えていることになります。
シミュレーションをリセットします。
[リミット]-[リミットで停止]を選択し、ロボットが届かない場合、それ以上動かないよう制限します。
シミュレーションを実行します。
ロボットがP2に向かう途中で、制限に達したため、ロボットが停止します。
シミュレーションをリセットします。
[リミット]-[メッセージパネル出力リミット]を選択し、ロボットが可動域を超えた場合、[出力]ウィンドウにメッセージを表示します。
シミュレーションを実行します。
ロボットが制限に達して停止したとき、[出力]ウィンドウにJ3がリミットを越えたという内容のメッセージが表示されます。
シミュレーションをリセットします。
ロボットアームの構成を確認します。
モーションステートメントは不要なため、右クリックし、削除します。
シミュレーションをリセットします。
[ツール]-[スナップ]を選択し、溶接トーチの位置を変更します。
溶接トーチを溶接パーツの外側の角に合わせます。
[ジョグ]ウィンドウを開きます。
[コンフィグ]を確認すると、ロボットの向きが「RIGHTY ABOVE NOFLIP」、つまり、フリップなしの右面になっています。
コンフィグは、ロボットの姿勢や向きを変更することができます。
[コンフィグ]を展開すると、選択肢が8つあることがわかります。
通常6軸のロボットは、8種類の構成を選択できます。
[各軸補間ステートメント]を選択し、現在の位置と向きを記録します。
[ステートメントプロパティ]ウィンドウの[コンフィグ]でロボットアームの向きを「RIGHTY ABOVE FLIPPED」、つまり、フリップありの右面にすると、J4が反転します。
シミュレーションをリセットします。
ロボットを選択し、[ジョグ]ウィンドウを開きます。
[ステートメントプロパティ]ウィンドウの[コンフィグ]を確認すると、ロボットの向きがフリップなしの右面になっています。
[PTP P1]を選択します。
[ステートメントプロパティ]ウィンドウの[コンフィグ]を確認すると、ロボットの向きがフリップありの右面になっています。
先ほど選択したロボットの向きが保存されていることがわかります。
[コンフィグ]の選択肢の1番目と2番目を交互に選択すると、TCPの位置は変わらず、ロボットの向きだけが変わることがわかります。
[コンフィグ]の選択肢の名称は、ロボットによって固有の名称が付いています。
他のロボットを配置し、名称を確認します。
[ホーム]タブを開きます。
eカタログの[タイプ別モデル]-[Robots]-[Visual Components]を開きます。
[ARC-2000i]を配置します。
[プログラム]タブを開きます。
[ジョグ]ウィンドウの[コンフィグ]を確認すると、名称が元から配置されているロボットと異なることがわかります。
名称の違いが確認できたため、追加したロボットを削除します。
ロボットのジョイントについての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットが届く範囲を確認しよう(4/5)

ロボットの特異点を回避する方法
https://youtu.be/dwW4GLj6K6Y
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_158_p4.zip

ロボットが届く範囲を確認する方法を説明します。
パート3では、ロボットのジョイントについて説明しました。
パート4では、ロボットの特異点の回避方法について説明します。
[Robot Reachability Part4_before.vcmx]をダウンロードし、開きます。
3Dワールドにロボット、コンベア、ボックスがあります。
ロボットは台座に乗っています。
ロボットを動かし、特異点を確認します。
特異点とは、ロボットが特定の姿勢になったとき、ロボットが制御できなくなることを言います。
ロボットが移動する際に、移動先への動きのパターンが無数にあり、ジョイントの動きが定まらない状況で発生します。
例えば、ロボットが伸び切った姿勢や2つ以上の軸が一直線上に並ぶ場合に特異点が発生します。
[プログラム]タブを開きます。
[マニピュレーション]-[ジョグ]が選択された状態で、ロボットを選択します。
特異点は、少なくとも6つの軸を持つロボットで発生します。
J5が0度の状態で、J4、J5、J6が一直線上にあるとき、特異点が発生します。
J4～6は現状0度ですが、この状態でJ4とJ6を動かしても、TCPの位置が変わりません。
つまり、J5が0度の状態で一直線上に並ぶ場合は、J4やJ6の値に関わらず、特異点が発生することになります。
シミュレーションをリセットします。
ロボットをシミュレーション中に動かし、特異点が発生したときのロボットの動作を確認します。
[リミット]-[特異点]を選択します。
[リミットで停止]を選択すると、特異点でロボットを停止することができます。
今回は、特異点が発生したときのロボットの動作を確認するため、チェックを外します。
[メッセージパネル出力]を選択し、特異点が発生したとき、[出力]ウィンドウにメッセージを表示します。
[ジョグ]ウィンドウの[座標]で[親]を選択します。
緑色の矢印を-Y軸方向にドラッグします。
[プログラムエディタ]-[各軸補間ステートメント]を追加します。
ロボットの動きを分かりやすくするため、動きを遅くします。
[ステートメントプロパティ]ウィンドウの[JointSpeed]を10％にします。
緑色の矢印を+Y軸方向にドラッグします。
[プログラムエディタ]-[直線補間ステートメント]を追加します。
[ステートメントプロパティ]ウィンドウの[MaxSpeed]を100mm/sにします。
ロボットのポジションが表示されていない場合は、ツールバーの[ロボットポジション]を有効にします。
PTP P1とLIN P2を選択すると、ロボットの移動先が分かります。
P1とP2では、ロボットとグリッパーの間のジョイントが回転しており、一直線上に並んでいないため、特異点は発生しません。
ただし、ロボットの向きを変更すると、特異点が発生する場合があります。
シミュレーションをリセットします。
ロボットを選択します。
[ジョグ]ウィンドウを開き、[コンフィグ]で[RIGHTY BELOW FLIPPED]を選択します。
J5を0にします。
緑色の矢印を左右にドラッグすると、J4、J5、J6がほぼ一直線上に並ぶため、特異点が発生する可能性があります。
シミュレーションをリセットし、ロボットを初期位置に戻します。
シミュレーションを実行し、ロボットの動作を確認します。
ロボットがP1を通ってP2に向かいます。
J5が0に到達すると、ジョイントが反転します。
また、[出力]ウィンドウに特異点が発生したことが表示されます。
[出力]ウィンドウを右クリックし、メッセージを削除します。
シミュレーションをリセットします。
[リミット]-[リミットで停止]を選択し、特異点でロボットを停止します。
シミュレーションを実行します。
ロボットが特異点で停止します。
[ジョグ]ウィンドウを確認すると、J5が0の時点で特異点が発生していることがわかります。
ロボットの軸が一直線上に並んだとき、ジョイント値の組み合わせが無数にあり、どのように動くべきか定まらず、ロボットが制御できなくなります。
シミュレーションをリセットします。
[出力]ウィンドウを右クリックし、メッセージを削除します。
ロボットの位置を変更し、別の例で特異点を確認します。
モーションステートメントを右クリックし、削除します。
シミュレーションをリセットします。
ロボットの位置を変更する前に、後程現在の位置にロボットを戻すため、現在の位置を保存します。
[プログラムエディタ]-[各軸補間ステートメント]を追加します。
ロボットの位置を変更します。
ビューセレクタの[R]をクリックし、右面を表示します。
青色の矢印を+Z軸方向にドラッグします。
[リミット]-[リミットで停止]のチェックを外します。
[ジョグ]ウィンドウのXとRyをクリックし、0にします。
J1を0にします。
Rzをクリックし、0にします。
現在の位置を初期位置として保存します。
シミュレーションコントロールの歯車を選択します。
状態の保存を選択すると、現在の位置とジョグのツールが保存されます。
赤色の矢印を+X軸方向にドラッグします。
[プログラムエディタ]-[各軸補間ステートメント]を追加します。
[ステートメントプロパティ]ウィンドウの[JointSpeed]を10％にします。
赤色の矢印を-X軸方向にドラッグします。
[プログラムエディタ]-[直線補間ステートメント]を追加します。
[ステートメントプロパティ]ウィンドウの[MaxSpeed]を100mm/sにします。
シミュレーションをリセットします。
P1はロボットの移動には不要なため、右クリックし、[有効/無効切り換え]を選択し、無効にします。
シミュレーションをリセットします。
[ジョグ]ウィンドウを開きます。
シミュレーションを実行します。
ロボットがP2を通ってP3に向かいます。
特異点が発生すると、ジョイントが反転します。
また、[出力]ウィンドウに特異点が発生したことが表示されます。
シミュレーションをリセットします。
[出力]ウィンドウを右クリックし、メッセージを削除します。
[リミット]-[リミットで停止]を選択し、特異点でロボットを停止します。
シミュレーションを実行します。
ロボットが特異点で停止します。
シミュレーションをリセットします。
[出力]ウィンドウを右クリックし、メッセージを削除します。
ロボットで箱を掴むように設定します。
ロボットが箱をピックアップする方法については、「ロボットでピック&プレイスを試してみよう」の動画を是非ご覧ください。
モーションステートメントを右クリックし、削除します。
PTP P1の位置を初期位置として保存します。
シミュレーションコントロールの歯車を選択します。
状態の保存を選択すると、現在の位置とジョグのツールが保存されます。
モーションステートメントを右クリックし、削除します。
[マニピュレーション]-[ジョグ]が選択された状態で、ピンク色の丸を箱の上にドラッグします。
[プログラムエディタ]-[直線補間ステートメント]を追加します。
[ステートメントプロパティ]ウィンドウで[名前]をGraspにします。
[MaxSpeed]を100mm/sにします。
青色の矢印を+Z軸方向にドラッグします。
[プログラムエディタ]-[各軸補間ステートメント]を追加します。
[ステートメントプロパティ]ウィンドウで[名前]をApproachにします。
[JointSpeed]を10％にします。
ApproachをGraspの上にドラッグします。
シミュレーションをリセットします。
[ジョグ]ウィンドウを開きます。
シミュレーションを実行します。
ロボットがApproachからGraspに向かいます。
J5が0に到達すると、特異点が発生し、ロボットが停止します。
また、[出力]ウィンドウに特異点が発生したことが表示されます。
[出力]ウィンドウを右クリックし、メッセージを削除します。
シミュレーションをリセットします。
特異点を回避するには、ロボットと箱の位置を変更し、J5が0に達する前に箱を掴むよう調整します。
ロボットを箱から遠ざけます。
[マニピュレーション]-[移動]を選択します。
[位置固定]-[ワールドに対して]を選択し、ロボットを動かしてもモーションステートメントが動かないように固定します。
[ステートメントプロパティ]ウィンドウの[座標]で[ワールド]を選択します。
ロボットを選択します。
赤色の矢印を+X軸方向にドラッグします。
[ジョグ]ウィンドウを開きます。
シミュレーションを実行します。
ロボットのJ5が0になる前に、箱を掴むことで、特異点を回避していることがわかります。
シミュレーションをリセットします。
ロボットの位置を元に戻します。
[ホーム]タブを開きます。
[マニピュレーション]-[PnP]を選択し、台座の上にロボットをドラッグします。
[プログラム]タブを開きます。
ロボットの高さを低くし、特異点を回避します。
[マニピュレーション]-[移動]を選択します。
青色の矢印を-Z軸方向にドラッグします。
[ジョグ]ウィンドウを開きます。
シミュレーションを実行します。
ロボットのJ5が0になる前に、箱を掴むことで、特異点を回避していることがわかります。
ロボットと台座が干渉しているため、台座の高さを変更します。
[コンポーネントプロパティ]ウィンドウを開きます。
Z軸座標をコピーします。
シミュレーションをリセットします。
台座の高さだけを変更するため、[コンポーネント]-[デタッチ]を選択し、一時的に接続を外します。
台座を選択します。
[コンポーネントプロパティ]ウィンドウのHに値をペーストします。
シミュレーションを実行します。
ロボットが台座に乗った状態で、特異点を回避します。
シミュレーションをリセットします。
ロボットの特異点の回避方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットが届く範囲を確認しよう(5/5)

ロボットのジョイントが制限を超えたときの対処方法
https://youtu.be/p__8ieVyShs
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_158_p5.zip

ロボットが届く範囲を確認する方法を説明します。
パート4では、ロボットの特異点の回避方法について説明しました。
パート5では、ロボットが可動域を超えた場合の対処方法について説明します。
[Robot Reachability Part5_1_before.vcmx]をダウンロードし、開きます。
3Dワールドにロボットと箱があります。
[プログラム]タブを開きます。
ロボットを選択します。
[サブプログラム]ウィンドウを確認すると、P1～P8のモーションステートメントがあります。
[リミット]-[リミットで停止]のチェックを外し[メッセージパネル出力]のチェックを選択します。
シミュレーションを実行します。
ロボットがP1～P8に沿って移動します。
[ジョグ]ウィンドウのJ6を確認すると、スライダーが赤くなっています。
J6にマウスオーバーすると、[Limits]が-360～360度のため、制限を超えている事がわかります。
シミュレーションをリセットします。
制限を超えないようにモーションステートメントの設定を変更します。
LIN P1を選択します。
直線補間ステートメントの代わりに、各軸補間ステートメントを使用します。
[各軸補間]ステートメントを追加します。
LIN P1を削除します。
シミュレーションをリセットします。
[ジョグ]ウィンドウを開きます。
シミュレーションを実行します。
[ジョグ]ウィンドウのJ6を確認すると、スライダーが赤くなっているため、まだ制限を超えていることがわかります。
シミュレーションをリセットします。
PTP P9を選択します。
[ジョグ]ウィンドウを開きます。
J6の矢印をクリックし、反転します。
[サブプログラム]-[タッチアップ]を選択し、現在の位置に更新します。
シミュレーションをリセットします。
シミュレーションを実行します。
事前にP9でJ6を回転しておくことで、P8まで移動した後も、制限を超えずに回転させることができます。
シミュレーションをリセットします。
別の例でロボットが制限を超えたときの対処法について説明します。
[Robot Reachability Part5_2_before.vcmx]をダウンロードし、開きます。
3Dワールドにロボットとパレットと箱があります。
[プログラム]タブを開きます。
ロボットを選択します。
[サブプログラム]ウィンドウを確認すると、7つのモーションステートメントと、箱を掴む、離す動作が設定されています。
動作を確認しやすくするため、シミュレーション速度を0.5にします。
シミュレーションを実行します。
ロボットが箱をピックアップし、もう片方のパレットに向かうとき、J6が回転していることがわかります。
このように、動作を設定する際に、意図しない回転が発生する場合があります。
シミュレーションをリセットします。
回転の動作を修正します。
LIN Upの後に停止ステートメントを追加します。
シミュレーションをリセットします。
シミュレーションを実行します。
シミュレーションが停止した後、[ジョグ]ウィンドウを確認します。
ロボットがパレット間を移動する前のJ6は、約-29度です。
緑色の矢印を-Y軸方向にドラッグします。
J6が回転しないようにするには、約+29度で移動すれば問題ないことが分かります。
Transportを選択し、[ジョグ]ウィンドウを開きます。
J6が約-330度になっているため、回転していることが分かります。
J6の矢印をクリックし、反転すると、約+29度になります。
[サブプログラム]-[タッチアップ]を選択し、現在の位置に更新します。
停止ステートメントは不要なため、削除します。
シミュレーションをリセットします。
シミュレーションを実行します。
J6が回転せずにロボットがパレット間を移動します。
シミュレーションをリセットします。
ロボットをレールに乗せて動かします。
[Robot Reachability Part5_3_before.vcmx]をダウンロードし、開きます。
3Dワールドにロボット、箱、パレットが2つあります。
ロボットはレールの上に乗っています。
[プログラム]タブを開きます。
ロボットを選択します。
[サブプログラム]ウィンドウを確認すると、4つのモーションステートメントと、箱を掴む動作が設定されています。
シミュレーション速度を1.0にします。
シミュレーションを実行します。
ロボットが箱をピックアップし、シミュレーションは止まります
ロボットをレールの端まで移動します。
ロボットとレールの接続方法については、「ロボットに外部軸を接続しよう」の動画を是非ご覧ください。
[ジョグ]ウィンドウを開きます。
ロボットはレールにアタッチしているため、[ジョグ]ウィンドウに「Robot Floor Track」があります。
[EJ_X]のスライダーを左右にドラッグすると、レール上のロボットの位置を変更できます。
[EJ_X]のスライダーを右にドラッグします。
[直線補間ステートメント]を追加します。
[ステートメントプロパティ]ウィンドウの名前をTransportにします。
シミュレーションをリセットします。
シミュレーションを実行すると、ロボットがレールの端まで移動します。
もう片方のパレットに箱を置く動作を追加します。
シミュレーションを実行します。
ロボットがパレットの箱をピックした後、レールを移動し、もう片方のパレットに箱を置きます。
シミュレーションをリセットします。
ロボットが箱をピックアップするときに、可動域を超えた場合の対処方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットでピック&プレイスしてみよう

ロボットで部品を掴む、離す動作を設定する方法
https://youtu.be/aPh78_0Dd8A
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_027.zip

ロボットのシグナルアクションを使用して、ピック＆プレイスする方法を説明します。
立方体をピックアップし、パレットの上に置く方法を説明します。
ロボットのシグナルシグナルアクションについて説明します。
デフォルトでは、ロボットのシグナル1から16は、つかむ、リリースのアクションを実行するように、事前定義されています。
3Dワールドで、ロボットを選択します。
コンポーネントプロパティの下側に、アクション設定という表示があります。
アクション設定を展開すると、ロボットのシグナルアクションを表示および定義できます。
シグナルアクションでは、ロボットの出力シグナルの番号を設定し、
シグナルの値がTrueのとき、Falseのとき、それぞれどのようなアクションを実行するかを定義することができます。
出力シグナルを1つ設定します。
[出力]で1を選択します。
シグナル1がTrueであるときつかみ、Falseのときはリリースすることが、事前定義されています。
シグナルアクションの下側、[つかむ]ではシグナル1は、
ロボットがコンポーネントをつかむ指令をしているときに、ツールフレーム{TOOL[1]｝を使用します。
ロボットに設定されている16個のツールフレームのうち、1番目のツールフレームを使用しています。
[使用ツール]で定義したツールフレームを中心に、[ボリュームサイズの検出]で定義した範囲内のコンポーネントをつかみます。
コンポーネントをリリースする場合は、つかんでいるコンポーネントを、
ツールフレームのZ軸方向にある別のコンポーネント、または3Dワールドにリリースします。
[重力の方向]では、別のコンポーネントを探す距離を定義しています。
ロボットのシグナルアクションについての説明は以上となります。
次に、ロボットのツールフレームについて説明します。
ロボットとグリッパーを接続し、ツールフレームをグリッパーの先端に移動します。
[PnP]をクリックし、グリッパーをロボットに接続します。
[プログラム]タブに移動し、
コマンド[ジョグ]をクリックし、ロボットを選択します。
ロボットを選択すると、プログラムエディタに、ロボットに設定されているプログラムが表示されます。
3Dワールドでツールフレームを表示したい場合は、3Dワールド右側にある[フレームタイプ]をクリックし、
ロボットツールのチェックボックスにチェックをつけます。
ツールフレームを表示することができます。
表示されたツールフレームを拡大して確認します。
ロボットとグリッパーの境目に、ツールフレームが16個重なって表示されます。
この位置がツールフレームのデフォルトの位置です。
｛TOOL[1]｝の位置のまま使用すると、コンポーネントをつかむときに問題があります。
グリッパーのツールフレームを使用し、{TOOL[1]}の位置を移動させます。
{TOOL[1]}をロボットの先端として使用したいので、
[ジョグ]ウィンドウの[ツール]で{TOOL[1]}を選択します。
{TOOL[1]}を編集するには、[ツール]横の歯車アイコンをクリックします。
{TOOL[1]}のプロパティが表示されます。
ドロップダウンメニューを使用すると、表示するツールフレームを変更することができます。
{TOOL[1]}の位置を、グリッパー先端に移動させたいので、
[ツール]グループの中にある[スナップ]を使用します。
[スナップ]をクリックすると、画面右側にスナップの設定が表示されます。
[モード]と[設定]では、移動する位置と向きを設定することができます。
3Dワールドのフレームの位置に移動するので、[スナップタイプ]から[フレーム]を選択します。
カーソルを3Dワールドに移動させると、フレームにカーソルを合わせたときだけ、フレームを囲む円が表示されます。
グリッパー先端の[GripperTCP]にカーソルを合わせ、クリックすると、
{TOOL[1]}が[GripperTCP]と同じ位置に移動します。
{TOOL[1]}の向きを確認します。
ツールプロパティの座標から[オブジェクト]を選択すると、
オブジェクトの現在の状態を、基準にした座標システムに変更することができます。
ロボットのツールフレームについての説明は以上となります。
ロボットに、立方体をピック＆プレイスするプログラムを設定します。
[ジョグ]ウィンドウに戻り、[ベース]から[Base_1]を選択し、[ツール]から[GripperTCP]を選択します。
ロボットの位置を指定するために、[GripperTCP]を使用するので、[ツール]では[GripperTCP]を設定しています。
ロボットを立方体の上面にスナップするので、コマンド[スナップ]を再度使用します。
[スナップタイプ]は[エッジと面]を使用します。
立方体の上面をカーソルを合わせると、グリッパーがどこにスナップされるかが表示されます。
立方体の上面の中心をクリックすると、そこにスナップします。
ロボットがその位置に移動しました。
[プログラムエディタ]の[Main]プログラムにいくつか、移動する位置を指定するステートメントを追加します。
[直線補間ステートメント]で立方体の上面位置を記録し、
ロボットを上に移動させ、もう一度[直線補間ステートメント]をクリックします。
この位置は、ロボットが立方体に接近する位置であり、後退位置でもあります。
ロボットを移動させず、[各軸補間ステートメント]をクリックし、
追加された[各軸補間ステートメント]をドラッグ＆ドロップでプログラムの一番上に配置します。
プログラムが実行されると、ロボットはP3の位置に移動し、立方体に接近し、
P1の位置に移動し、立方体と接触し、P2の位置に移動しますが、
シグナルを出力していないので、つかむアクションを実行しません。
P1の位置に移動した後、立方体をつかみたいので、P1の下にシグナルを出力するステートメントを追加します。
P1を選択し、[セットバイナリ出力ステートメント]をクリックします。
P1の下に[セットバイナリ出力ステートメント]が追加されました。
デフォルトでは、シグナル0を使用し、値がFalseの状態で出力しています。
シグナル1を値がTrueの状態で出力し、シグナル1がTrueのときにあるつかむを実行したいので、
セットバイナリ出力ステートメントの設定を変更します。
ステートメントプロパティの、バイナリ出力ステートメントに1と入力し、出力値のチェックボックスにチェックをつけます。
[プログラムエディタ]を確認すると、Set OUT[1] = Trueに変更されています。
動作を確認するので、シミュレーションのリセットボタンをクリックし、ロボットの位置を初期状態に戻します。
シミュレーションを実行すると、P3、P1と移動し、立方体をつかみました。
ロボットが立方体を、つかむところまで完了しました。
次は、立方体をパレットまで移動する設定を行います。
コマンド[ジョグ]が選択されている状態で、パレットの方向に移動します。
この位置を[各軸補間ステートメント]で記録します。
立方体を持ち上げた後、移動するので、P2の下に追加します。
プログラムが長くなる場合は、別のサブルーチンを追加することもできますが、
今回は[Main]プログラムの1つを使用する構成にします。
立方体をつかんだ後、ロボットはP4に移動しますが、今度はパレットに立方体を置く必要があります。
立方体の角を、パレットの面にスナップします。
立方体の角が確認できるように拡大し、視点の角度を変更し、立方体を下から見上げます。
[ツール]グループの[スナップ]をクリックし、パレットにカーソルを合わせると、
立方体を無視して、スナップしようとします。
[スナップ]をキャンセルし、[整列]をクリックします。
[整列]は、2つの位置を使用し、選択したオブジェクトを整列させます。
[スナップタイプ]を、[エッジと面]に変更し、
立方体の底面の中心をクリックし、パレットの中心をクリックすると、
ロボットが、パレットの上面に立方体を置く姿勢になりました。
[直線補間ステートメント]をクリックし、P4の下に、位置を記録します。
ロボットが、移動し、パレットに立方体を置く姿勢になりますが、
シグナルの値をFalseを出力していないのでリリースしません。
P5に移動した後、シグナル1の値をFalseで出力します。
P5の下に[セットバイナリ出力ステートメント]を追加し、
[バイナリ出力ステートメント]に1と入力し、出力値をFalseに設定するので、ここではチェックボックスにチェックをつけません。
リリースした後、ロボットを上に移動させるので、P4を選択し、
[直線補間ステートメント]を追加し、追加されたP6をSet OUT[1]=Falseの下にドラッグ＆ドロップします。
そシミュレーションをリセットし、シミュレーションを実行します。
ロボットが立方体をピックアップし、パレットにリリースしました。
ロボットのシグナルアクションを使用して、ピック＆プレイスする方法についての説明を終了します。

=================================================================================

ロボットでワークを積み上げてみよう

ロボットで部品を積み上げる方法
https://youtu.be/D-v61UZKlu4
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_026.zip

ロボットをプログラムするときWHILEステートメントを使用する方法を説明します。
コンベア上の円柱を持ち上げパレットに配置するプログラムが設定されたロボットがあります。
ロボットのプログラムを確認します。
コンベア上の円柱を持ち上げるための PickCylinderと呼ばれるサブルーチンがあります。
PlaceCylinderはコンベア上のパレットに円柱を配置するサブルーチンです。
メインルーチンでは円柱を持ち上げ配置するプロセスを継続的に実行するため、Whileステートメントを設定しています。
Whileステートメントは条件がTrueになるときは中のプログラムを繰り返し実行します。
動作を確認するためにシミュレーションを再生します。
コンベア上を円柱とパレットが流れます。
ロボットはセンサーからシグナルが送信されるまで待機します。
円柱を持ち上げパレットに配置しました。
パレットが移動します。
WhileステートメントにTrueの条件を設定しているためロボットはプログラムを繰り返し実行します。
3Dワールドのレイアウトをすべて削除します。
WHILEステートメントを使用している「Pick and Place Parts」という名前のレイアウトを開きます。
レイアウトは同じですがロボットに高度な動作をするプログラムが設定されています。
[プログラム]タブをクリックしロボットを選択します。
[プログラム]エディタには2つのサブルーチンとメインルーチンがあります。
メインルーチンには複数のWhileステートメントが設定されています。
メインルーチンを選択し、[ルーチンプロパティ]に移動します。
3つの整数型変数countX、countY、countZがあります。
1列に配置された円柱を数える変数、列数を数える変数、総数を数える変数です。
パレットに円柱を積み上げます。
シミュレーションを再生します。
ロボットは円柱が到達しシグナルが送信されるまで待機します。
円柱を持ち上げパレットに配置します。
同じパレットに2つ目の円柱を配置します。
ロボットがパレットの同じ列に必要な個数の円柱を配置し次の列に円柱を配置します。
シミュレーションの速度を上げます。
ロボットが一つの層に必要な個数の円柱を配置し次の層に円柱を配置します。
円柱の配置が終わるとパレットがコンベアを流れます。
シミュレーションを一時停止します。
[プログラムエディタ]のメインルーチンを確認します。
1番目のWhileステートメントは条件がTrueに設定されています。
2番目のWhileステートメントはロボットが円柱を配置する層を制御するため、countZ変数を使用し2つの層が必要であることを設定しています。
3番目のwhileステートメントはcountY変数を使用し、一つの層に円柱が2列必要であることを設定しています。
4番目のWhileステートメントはcountX変数を使用し1列に3つの円柱が必要であることを設定しています。
4番目のWhileステートメントの中で円柱を持ち上げ配置します。
円柱を配置後countX変数の値に1加算します。
3つの円柱を配置し3番目のWhileステートメントに進みます。
列数を数えるためcountY変数の値に1加算しcountX変数を0に戻します。
4番目のWhileステートメントに戻り1列に必要な個数の円柱を配置します。
円柱を2列配置後3番目のWhileステートメントから抜け2番目のWhileステートメントに進みます。
必要な数の層になるまで円柱を配置します。
円柱を数えている間ロボットのベースフレームを定義し円柱を配置する位置をパターン化します。
PlaceCylinderを選択します。
パレットに接近、交代する位置はBase2を変更することでシミュレーション中に自動的に更新することができます。
ベースフレームを表示する場合フレームタイプのロボットベースにチェックをつけます。
Base2が表示されます。
円柱を配置しBase2の位置が移動します。
円柱を配置する位置が更新されます。
次の位置に円柱を配置する際ベース定義ステートメントによりBase2の位置が移動します。
2列目まで円柱を配置した後はBase2が移動し、新しい層に円柱を配置します。
Base2はパレットの位置から上に移動します。
円柱を配置する列数を変更します。
[プログラムエディタ]のメインルーチンを選択します。
列数を変更するため3番目のWhileステートメントを選択します。
条件をcountYが2未満からcountYが3未満に変更します。
シミュレーションを再生します。
ロボットが円柱を2つ目の層に配置するとき問題が発生します。
列を追加したためBase2のオフセットを設定し次の層に割り当てる必要があります。
2 列目に配置します。
3列目に配置します。
1つ目の層は問題ありません。
2つ目の層に配置するときBase2の位置とロボットの移動する位置を確認します。
Base2のオフセットを変更する必要があります。
円柱の半径は30mmです。
Shape Feederを選択し[ProductParams]をクリックします。
シミュレーション中に生成する円柱の半径は30mmであるため、Base2を使用しているオフセットに60mm追加する必要があります。
次の層に移動するときのオフセットに60mm追加します。
[プログラムエディタ]に移動します。
円柱を持ち上げ、列に配置します。
ベース定義ステートメントで配置する位置を更新し次の層に円柱を配置します。
ベース定義ステートメントの[ステートメントプロパティ]では-120mmのオフセットが設定されています。
円柱を2列配置していましたが、3列配置するためオフセットに60mm追加するために-180と入力します。
シミュレーションを再生します。
円柱が3列配置されました。
次の層に円柱を配置する前にシミュレーションを一時停止し、ベースフレームが適切な位置になっていることを確認します。
シミュレーションの速度を上げます。
動作を確認します。
シミュレーションの速度を上げます。
次のパレットに円柱を配置します。
ロボットのプログラムをループさせたときのトラブルシューティング方法を説明します。
一つ目の方法はステートメントを内側から作っていくことです。
一つの円柱を配置するために必要なステートメントを作成します。
Whileステートメントを作成し、変数で配置する円柱の個数を定義します。
変数の値を加算しシミュレーション中にベースフレームの位置を調整します。
配置する円柱の寸法と配置する位置に必要な個数円柱を配置します。
変数を作成し必要な列数を定義します。
変数の値に加算しベースフレームの位置を調整します。
4番目のWhileステートメントを完了し3番目のWhileステートメントを実行します。
2つ目の方法はシミュレーションを停止することです。
停止ステートメントを作成し、ロボットプログラムの必要な場所に挿入します。
円柱を3列並べ変数の値に加算します。
ベースフレームの位置を変更します。
新しい列に円柱を配置する前に停止ステートメントを挿入します。
列数を制御するWhileステートメントの上に停止ステートメントを挿入したため、停止しませんでした。
次の層に円柱を配置する前に停止するようにします。
1つ目の層に円柱を配置し終わりシミュレーションが停止しました。
ベースフレームの位置を確認するためにシミュレーションを停止しました。
シミュレーションが停止している間、ロボットプログラムに停止ステートメントを追加することもできます。
ロボットが円柱を1列配置し、シミュレーションが停止します。
シミュレーションが停止しているため再開します。
3つの円柱を配置しシミュレーションが停止しました。
ロボットがあるBase2の位置を確認します。
PlaceCylinderを選択し、停止ステートメントを追加することができます。
ロボットが円柱を配置するため下に移動することでシミュレーションは停止します。
トラブルシューティングを行うとき、ロボットプログラムに複数の停止ステートメントがある場合、実行しているステートメントがわからなくなる可能性があります。
プログラム内の停止ステートメントはできるだけ少なくします。
シミュレーション中にルーチン変数の値を確認することができます。
シミュレーションをリセットします。
シミュレーションを再生する前にメインルーチンを選択します。
シミュレーションを再生しルーチンプロパティを確認します。
ルーチン変数が表示され、値の更新を確認することができます。
countX変数は2から0に戻り、countY変数は1になりました。
次の列に配置が完了することでcountY変数は2になります。
countZ変数が1になるためには1つ目の層に円柱に配置が完了する必要があります。
countZ変数が1になりました。
ロボットをプログラムするときWhile ステートメントを使用する方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

ロボットで製品を塗装しよう

Gemini Premiumの機能です。
Paint Gun（塗装ガン）をロボットに取り付け、板に塗装する方法
https://youtu.be/afIBslbOQEA
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_170.zip

ロボットで製品を塗装する方法を説明します。
この動画では、Premiumの機能を使用します。
ロボットに塗装ガンを取り付け、板を塗装するよう設定します。
塗装を設定するためのアドオンを追加します。
[ファイル]タブを開きます。
[オプション]-[アドオン]を選択します。
[ペイント]の[有効にする]ボタンをクリックし、ペイントのアドオンを表示します。
戻るボタンをクリックします。
ロボット、塗装ガン、塗装用の板を追加します。
eカタログの[タイプ別モデル]-[Robots]-[Mitsubishi Electoric]を展開します。
[RV-7FRL]をダブルクリックし、原点に追加します。
[タイプ別モデル]-[Robot Tools]-[Visual Component]を展開します。
[Paint Gun]を追加します。
[マニピュレーション]-[PnP]が選択された状態で、Paint Gunをロボットに接続します。
[タイプ別モデル]-[Basic Shapes]-[Visual Components]を展開します。
[Block Geo]を追加します。
X座標を1100、Y座標を0にします。
[コンポーネントプロパティ]ウィンドウでブロックのサイズを変更し、板状にします。
[Height_Z]に1000を入力します。
[Length_X]に1を入力します。
[Width_Y]に1500を入力します。
カメラの視点を背面側にします。
塗装ガンを設定します。
[Paint Gun]を選択します。
[モデリング]タブを開きます。
[コンポーネントグラフ]ウィンドウの[Paint Gun]-[プロパティ]-[SprayOn]を選択します。
[プロパティ]ウィンドウの[表示]にチェックを入れ、[コンポーネントプロパティ]ウィンドウに[SprayOn]の項目を表示します。
[SprayOn]で1を選択し、塗装範囲を可視化します。
[閉じる]ボタンをクリックします。
塗装ガンをダブルクリックします。
[コンポーネントプロパティ]ウィンドウを確認すると、[SprayOn]が表示されていることがわかります。
[ShowBitmapPlanes]にチェックを入れると、塗装の距離を平面で表示できます。
[VisualizedConeSize]は、塗装範囲を示すコーンのサイズを変更できます。
[VisualizedConeSize]に100を入力します。
[SamplesFrequency]は、塗料分布の周波数（1秒あたりの計算サイクル）を定義します。
高い値を設定すると、PCのパフォーマンスに負荷が掛かりますが、より詳細な塗装の分布を生成できます。
[GunEfficiency]は、塗料のフロー全体の効率係数を定義します。
[FlowRate]は、1秒間に表面に分布する塗料の量を定義します。
[FlowRate]に10を入力します。
[Spray Min Distance]と[Spray Max Distance]は、塗装ガンの最小塗装距離と範囲を設定できます。
[SprayDiamaterX]は、スプレーの楕円のX軸方向の直径を設定します。
[SprayDiamaterY]は、スプレーの楕円のY軸方向の直径を設定します。
[SignalPort]は、塗装ガンとロボットを接続するときに自動的に使用されるポート番号を指定します。
デフォルトで、101が入力されています。
[接続]-[シグナル]を選択します。
ロボットをクリックすると、使用されているシグナルが表示されます。
SpraySignalは、ロボットの出力シグナルの101を使用していることがわかります。
[閉じる]ボタンをクリックし、塗装ガンをダブルクリックします。
[OcclusionTest]にチェックを入れると、レイトレーシング・メソッドを使用する際に、描画された領域が他のコンポーネントによって遮られているかを検出できます。
[PaintedNodes]は、塗装ガンの影響を受けるノードを事前に定義できます。
[Distribution]タブを開きます。
[DistributionMap]は、ビットマップを使用して、塗装ガンのノズルからの距離ごとに塗料の分布を定義します。
[MapDistances]の数値の間の分布はブレンドされます。
分布図のビットマップが同じである場合、塗装ガンのノズルからの表面の距離に関係なく、同じ分布になります。
分布図のビットマップは、幅＝n×高さのサイズのjpgファイルです。
n はレイヤー数 / マップの距離です。
[TCP]タブを開きます。
[OffsetFromTheNozzle]は、ティーチング時のTCPポイントと塗装ガンの距離を定義します。
[プログラム]タブを開きます。
[ペイント]タブが表示されるため、開きます。
[ペイントのコンポーネントを準備]を選択し、塗装したいコンポーネントをクリックします。
今回は、板を塗装するため、板をクリックします。
[ペイントの準備]ウィンドウでコンポーネントの三角ポリゴンを細分化します。
塗料の厚みは三角ポリゴンの頂点に保存されます。
三角ポリゴンを細分化し、頂点数が増えるほど、塗装は滑らかになりますが、PCのパフォーマンスに負荷が掛かります。
[エッジの最大の長さ]で、三角ポリゴンのエッジの長さを設定し、三角ポリゴンをどの程度細分化するかを決めることができます。
[エッジの最大の長さ]に30を入力します。
ポリゴンの状態を確認するため、レンダリングモードを[ワイヤフレーム]にします。
[ペイントの準備]ウィンドウの[選択済みコンポーネントを準備]を選択します。
板を確認すると、三角ポリゴンが細分化され、塗装対象になったことがピンク色で示されています。
レンダリングモードを[シェード]に戻します。
ロボットに塗装のプログラムを設定します。
[プログラム]タブを開きます。
ロボットを選択します。
[サブプログラム]-[Main]に[各軸補間ステートメント]を追加します。
[各軸補間ステートメント]は、ロボットの位置を記録し、ジョイントの値を補間して動かすことができます。
[マニピュレーション]-[ジョグ]を選択します。
板の左下に向かって塗装ガンを動かし、塗装ガンのノズルが板に向くように角度を調整します。
[直線補間ステートメント]を追加します。
[直線補間ステートメント]は、ロボットの位置を記録し、最短距離で動かすことができます。
塗装を開始するため、ロボットの出力シグナルの101をTrueにします。
[セットバイナリ出力ステートメント]を追加します。
[ステートメントプロパティ]の[バイナリ出力ステートメント]を101にします。
[出力値]にチェックを入れて、Trueにします。
塗装ガンを+Z軸方向に移動し、[直線補間ステートメント]を追加します。
塗装ガンを-Y軸方向に移動し、[直線補間ステートメント]を追加します。
塗装を終了するため、ロボットの出力シグナルの101をFalseにします。
[Set Out[101]]をコピーし、貼り付けます。
[ステートメントプロパティ]の[出力値]のチェックを外し、Falseにします。
塗装ガンをP1と同じような位置に戻し、[直線補間ステートメント]を追加します。
シミュレーションをリセットします。
シミュレーションを実行します。
板が塗装されます。
ペイントの色や濃度は、[ペイント]タブで設定することができます。
[ペイント]タブを開きます。
[ペイントを表示]の色が選択された状態で、[色マップを編集]を開きます。
[色マップエディタ]の[Paint Thickness]と[Color]で、塗料の厚みによって色を変更することができます。
[測定]-[ペイントの厚さ]を選択し、[ペイント測定ツール]を使用して、塗装された塗料の厚さを測定することができます。
塗料にマウスオーバーすると、厚さが表示されます。
塗料をクリックすると、クリックした箇所の厚さが常に表示されます。
塗装の理論について説明します。
1秒ごとに表面に分布できる塗料の量は、このような計算に基づいています。
Volumeは、塗装ガンの円錐のAreaに分布されます。
Areaはこのような計算に基づいています。
塗装ガンは楕円を描画領域として使用しているため、塗料の濃度分布図である白い範囲は、円形領域である赤い範囲の中にあるはずです。
分布図が「完全な白」の場合、表面に分布する塗料の厚さは、このような計算に基づいています。
分布図の解像度は、計算における"ピクセル"あたりの塗料の合計に影響するため、厚みの結果にわずかに作用します。
分布図が「完全な白」でない場合、塗料の量はマップのピクセルの値に基づいて黒以外の領域に分布されます。
したがって、100％白のピクセルには、「完全な白」のときよりも多くの塗料が適用されます。
彩度は、マップ上の「白」の総量を累積することによって、マップごとに計算されます。
次に、マップの総塗料面積を先ほど計算した値で割って、そのマップの彩度乗数を得ます。
つまり、合計の厚さは、このような計算に基づいています。
1秒間に噴射される塗料の量は同じであるため、分布図や面積を小さくすると、より広がった、大きな分布図よりもはるかに厚い塗料になります。
分布図は、マップ距離間でブレンドされます。
1つの「レイヤー」の塗料が表面に分配される頻度は、塗装結果に影響します。
ロボットやロボットの先端に取り付けるツールの移動速度が速いほど、SamplesFrequencyの値を増やす必要があります。
表面の角度と塗装ガンのノズルの角度は、同じ量の塗料が当たったときの表面積を増やすことで、塗料の厚みに影響を与えます。
同じ量の塗料が当たった場合、表面積は大きくなります。
ただし、塗料粒子の距離も異なる場合があり、異なる塗料粒子は、異なる分布マップを使用する可能性があります。
ロボットで製品を塗装する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットで複数のワークを同時に掴んでみよう

ロボットで複数の部品を同時に掴む方法
https://youtu.be/dkZOivrJ62k
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_021.zip

ロボットが複数のコンポーネントをつかむ方法を説明します。
レイアウトを作成しロボットに指示を出す方法を説明します。
3Dワールドに何も配置されていないことを確認します。
eカタログの[タイプ別モデル]を展開し[Feeders]をクリックします。
ロボットがつかむワークを生成するものが必要であるため、Basic Feederをダブルクリックし、3Dワールドに追加します。
[コンポーネントプロパティ]に移動し、フィーダーの幅を変更する[ConverWidth]を「200」に設定します。
コンベアを追加します。
eカタログのConveyorsを展開し、Visual Componentsをクリックします。
一度に複数のコンポーネントをつかむため、複数種類のコンポーネントを生成できるコンベアを追加します。
Product Batcher Conveyorを3Dワールドにドラッグします。
PresetsをRoll Conveyorに変更しフィーダーに接続します。
コンポーネントプロパティでAutoPropertiesにチェックが付いているためコンベアの幅が自動的に変更されます。
コンベアに接続したフィーダーと一致するプロパティがある場合自動的に変更されます。
コンベアの幅は200に変更されました。
コンポーネントのバッチサイズはバッチサイズで制御します。
バッチは3つのコンポーネントで構成します。
ポストバッチタスクでBatchSignalToRobotを選択します。
3つのコンポーネントを取得することでバッチを作成し、削除することができます。
コンポーネントを削除せずロボットで掴むためDeleteFinishedBatchは選択しません。
バッチ内のすべてのコンポーネントをまとめ1つのコンポーネントとして移動します。
ロボットに手動で指示を出しシグナルに依存している場合、1つのコンポーネントにまとめることは困難なため、PackBatchToOneComponentのチェックを外します。
コントローラコンポーネントを使用し、コンポーネントを自動的につかむ場合チェックをつけます。
今回はチェックを外した状態にします。
シミュレーションを再生し速度を上げます。
フィーダーが円柱を生成しました。
円柱は半径が50高さが100です。
バッチは3つのコンポーネントで構成されています。
3つのコンポーネントがあることを確認します。
ロボットとグリッパーを追加しロボットにコンポーネントをつかむ指示を出します。
シミュレーションをリセットします。
eカタログの[タイプ別モデル]の下にある[Robots]を展開します。
Visual Componentsをクリックし、Generic Articulated Robotを3Dワールドに追加します。
ロボットをコンベア上のコンポーネントに届く位置に移動します。
グリッパーを追加しロボットに接続します。
eカタログのRobot Toolsを展開しVisual Componentsをクリックします。
Parametric Gripperを3Dワールドに追加するためドラッグし、ロボットに接続します。
バッチサイズは3つのコンポーネントで構成されているためグリッパーを大きくする必要はありません。
グリッパーの吸盤が1列に並んでいる必要があります。
シミュレーションを一時停止します。
グリッパーを選択しコンポーネントプロパティで[SuctionCups_Y]を「1」に変更します。
3つの吸盤が1列に並んでいます。
コンポーネントをつかみ別の位置に配置する設定をします。
フィーダーとコンベアをロボットの反対側に追加する必要があります。
eカタログのタイプ別モデルの下にあるFeedersをクリックし、3DワールドにShape Feederを追加します。
上方からの視点に切り替えShape Feederを移動します。
Shape Feederが生成するワークを変更します。
コンポーネントプロパティでProductをEmpty Boxに変更します。
円柱を箱の中に格納します。
コンベアに沿い移動し停止させます。
ロボットに接続することができるセンサーとコンベアを追加します。
eカタログの[タイプ別モデル]の下にあるConveyorsを展開しVisual Componentsをクリックします。
Sensor Conveyorをドラッグし3Dワールドに追加します。
Shape Feederに接続します。
レイアウトを構築したためロボットプログラムを設定します。
ロボットが一度に複数のコンポーネントを掴みます。
ロボットを選択し[コンポーネントプロパティ]で[シグナルアクション]タブをクリックします。
[マルチグラスプ]にチェックを付けます。
コンポーネントをつかむまたは解放するとき、ロボットは複数のコンポーネントを検出することができます。
検出したコンポーネントをすべてつかむまたは解放することができます。
[プログラム]タブをクリックしロボットプログラムを設定します。
ジョグを使用しロボットを選択します。
ロボットをBatcher ConveyorとSensor Conveyorのシグナルに接続し動作を確認します。
[接続]グループの[シグナル]をクリックします。
ロボットには入力と出力があります。
ロボットの入力とBatcher Conveyorのシグナルを接続します。
Batcher Conveyorのシグナルエディタを展開します。
BatchReadySignalの横にある丸をドラッグすることで線を表示するため、ロボットの入力までドラッグします。
シグナル番号を0から50に変更します。
コンベア内のバッチの準備ができたとき、BatchReadySignalがロボットにシグナルを送信します。
Sensor Conveyorのセンサーが箱を検出しシグナルを送信する必要があるため、Sensor Conveyorのシグナルエディタを展開します。
SensorSignalとロボットの入力を接続します。
丸をドラッグし線が表示されるため、ロボットの入力までドラッグします。
シグナル番号を0から51に変更します。
箱がセンサーに到達したときコンベアを停止します。
「StartStop」の丸をドラッグすることで線が表示されるためロボットの出力までドラッグします。
ロボットがシグナルの値を設定するため「StartStop」を送信します。
シグナル番号を0から51に変更します。
シグナル50はBatcher Conveyor用、シグナル51はSensor Conveyor用です。
[接続]グループの[シグナル]をクリックします。
動作を確認します。
[プログラムエディタ]に移動します。
センサーが箱を検出するまで待機するため、Mainルーチンにバイナリ入力待機ステートメントを追加します。
[ステートメントプロパティ]ではポート51からシグナルを送信し、値がTRUEになるまで待機します。
ロボットからシグナルを送信するため、セットバイナリ出力ステートメントを追加します。
バイナリ出力ステートメントを51に設定します。
ポート51に接続されているシグナルの値をFalseの状態で送信するため、出力値のチェックはつけません。
動作を確認するためシミュレーションを再生します。
センサーが円柱を検出し箱を停止しました。
バッチを掴む準備ができたことを通知するシグナルをロボットが受信するまで待機します。
シミュレーションをリセットします。
[プログラムエディタ]に戻りバイナリ入力待機ステートメントを追加します。
ロボットはBatcher Conveyorからシグナルを受信するまで待機します。
ポート50からシグナルを送信します。
入力値をTRUEにしトリガーにチェックを付けます。
シグナルイベントを待機し、ロボットがポート50に接続されたシグナルの値を処理します。
値がTRUEのときイベントまたは更新を取得しシグナルの値が変更された場合ロボットはバッチの準備ができていることを認識します。
動作を確認します。
[プログラムエディタ]でシグナルを受信後シミュレーションを停止するため、停止ステートメントを追加します。
シミュレーションを再生します。
センサーが箱を検出しコンベアを停止しました。
3つの円柱がBatcher Conveyorを流れシミュレーションが停止しました。
ロボットで円柱をつかみ箱に格納します。
ロボットに使用するツールフレームを設定する必要があります。
ロボットを選択した状態で[ジョグ]ウィンドウに移動します。
使用するベースフレームにベース1を設定します。
グリッパーからインポートしたツールフレームであるダブルツール1を使用することができます。
ロボットにはコンポーネントをつかむ開放する設定がされているため、ロボットのアクションを構成する必要はありません。
つかむ開放を実行するとき使用するツールフレームに設定済みのツール1を使用します。
歯車アイコンをクリックしツール1を選択します。
ツール1をグリッパーの先端にあるダブルツール1-1に移動します。
3Dワールドツールバーのフレームタイプをクリックしロボットツールにチェックをつけます。
ロボットのツールフレームが表示されます。
グリッパーの先端にダブルツール1があるためツール1を移動します。
[ツール]グループの[スナップ]をクリックします。
[スナップタイプ]を「フレーム」に変更することで3Dワールドのフレーム位置に移動することができます。
ダブルツール1をクリックします。
ツール1が移動します。
オブジェクト座標に変更しツールフレームの向きを確認します。
ツールフレーム独自の座標に変更し+Z軸がグリッパーの吸盤が向いている方向を指していることを確認します。
レイアウトを保存するまたは参照レイアウトを読み込みます。
インポートしたツールフレームを使用し、ロボットにグリッパーを接続します。
[ジョグ]ウィンドウで[ツール]に「ダブルツール」を設定します。
シミュレーションを再生します。
ロボットがバッチの準備ができたことを通知し円柱をつかむ位置を指示します。
シミュレーションを一時停止しました。
ロボットを中心の円柱位置に移動します。
[ツール]グループの[スナップ]をクリックします。
円柱の上面中心をクリックしグリッパーが円柱をつかむ位置に移動します。
ロボットが移動する指示を別のサブルーチンに設定します。
[プログラムエディタ]で+ボタンをクリックしサブルーチンを追加します。
名前をPICK BATCHに変更します。
円柱を掴む位置を設定するため直線補間ステートメントとセットバイナリ出力ステートメントを追加します。
セットバイナリ出力ステートメントのステートメントプロパティを設定します。
ツール1を使用しコンポーネントをつかむ設定がされているシグナル1を設定します。
出力値にチェックをつけます。
円柱をつかみ持ち上げます。
円柱に接近する位置と持ち上げる位置を設定します。
ツールフレームのオブジェクト座標を使用し位置を設定します。
ロボットの位置を戻しZに300と入力します。
ロボットが上に移動します。
直線補間ステートメントと各軸補間ステートメントを追加します。
各軸補間ステートメントをサブルーチンの一番上に移動します。
ロボットは円柱をつかみ持ち上げます。
メインルーチンでサブルーチンを呼び出す必要があります。
停止ステートメントの前に呼び出すためバイナリー入力待機ステートメントの下に追加します。
コールシーケンスステートメントを追加し[ステートメントプロパティ]でPICK BATCHを設定します。
シミュレーションをリセットし再生します。
動作を確認します。
3つ目の円柱が流れロボットが移動します。
掴んでいる円柱は一つです。
3つの円柱をつかむためシグナルアクションの検出範囲を変更する必要があります。
検出範囲の変更方法を説明します。
シミュレーションをリセットします。
ジョグでロボットを選択します。
[コンポーネントプロパティ]にはアクション設定があります。
ロボットをコンポーネントとして選択することでアクション設定を表示することができます。
アクション設定を展開し出力を1に設定します。
ツール1を使用します。
シグナル1の値がTRUEの場合コンポーネントをつかみます。
シグナル1の値がフォルスの場合コンポーネントを解放します。
コンポーネントをつかむときボリュームサイズを検出を設定することで、検出範囲内のコンポーネントを検出することができます。
ロボットで複数のコンポーネントをつかむため、検出範囲の設定を変更します。
ツール1を検出範囲の原点に使用しています。
[プログラムエディタ]でピックバッチを呼び出す前に停止ステートメントを移動します。
シミュレーションを再生します。
3つ目の円柱が流れます。
3つの円柱をつかむために必要な検出範囲の大きさを測定します。
[ツール]グループの[測定]をクリックします。
1つ目と3つ目の円柱の端から端までを測定します。
測定の結果は約300mmです。
P1を中心に両側に150mmの立方体または直方体を作成することで3つの円柱を検出することができます。
測定を閉じます。
ロボットを選択し[コンポーネントプロパティ]に戻ります。
シグナルアクションで出力を1に設定します。
ボリュームサイズを検出のX軸を変更します。
ロボットのツールフレームが下を向いておりX軸は正の方向を向いています。
ボリュームサイズを検出のX軸を150に変更します。
意図しないコンポーネントをつかむ可能性があるため検出範囲は必要な大きさに設定します。
X軸を150に設定することで検出範囲はP1を中心にプラスマイナスX軸方向に150に設定されます。
Y軸方向は50、Z軸方向は下に50です。
シミュレーションをリセットします。
停止ステートメントの位置を変更するためピックバッチの下にドラッグします。
シミュレーションを再生し動作を確認します。
3つ目の円柱が流れましたロボットが移動します。
3つの円柱を検出し掴みました。
ツールフレームの座標を参照しているためグリッパーの下に向かい検出範囲を作成し3つの円柱を検出しています。
円柱を箱の中に格納します。
[プログラムエディタ]で新しいサブルーチンを追加し名前をプレース バッチに変更します。
円柱を箱の中に移動するため整列を使用し ます。
[ツール]グループの[整列]をクリックし、中心にある円柱の原点を 箱の原点に移動します。
[整列]ウィンドウで[スナップタイプ]を「原点」に変更します。
中心にある円柱の原点をクリックします。
箱の原点にカーソルを合わせクリックします。
[ツール]グループの[測定]をクリックし、箱の原点から面までの距離を測定します。
約10mmです。
測定を閉じます。
ジョグに移動します。
ツールフレームのオブジェクト座標で移動するためオブジェクトに切り替えます。
10mm移動するため、Z軸にマイナス10と入力します。
ロボットが上に移動しました。
ロボットが箱の内側に衝突しているためグリッパーを回転させます。
ジョグパネルでRzを90に設定します。
ロボットに移動する指示を出します。
プレースバッチに直線補完ステートメントとセットバイナリ出力ステートメントを追加します。
[ステートメントプロパティ]でバイナリー出力ステートメントに1を設定します。
コンポーネントを解放するため出力値はFalseに設定します。
円柱を開放後の位置と箱に接近する位置に移動する指示を出します。
ロボットを上に移動します。
直線補間ステートメントと各軸補間ステートメントを追加し各軸補間ステートメントをプレースバッジの一番上に移動します。
ロボットは箱に接近し円柱を離します。
プレースバッジをメインルーチンで呼び出します。
メインルーチンをクリックします。
ピックバッチを呼び出しプレースバッチを呼び出します。
コールシーケンスステートメントを追加しプレースバッチを設定します。
Sensor Conveyorをオンに戻すためセットバイナリ出力ステートメントを追加します。
Sensor Conveyorはポート51と接続したためバイナリ出力ステートメントに51と入力します。
ポート51に接続したシグナルをTRUEに切り替え、センサーのStartStopSignalでパスをオンに戻します。
停止ステートメントを選択しデリートキーを押して削除します。
シミュレーションをリセットします。
動作を確認します。
エラーが発生しました。
円柱が3つ流れるまで待機します。
円柱を掴みましたが、箱の中に格納できなかったため円柱と箱は別々に移動します。
シミュレーションをリセットします。
プログラムエディタでプレースバッチを選択します。
停止ステートメントを追加します。
シミュレーションを再生します。
ロボットが円柱を箱に格納しました。
円柱を解放するときロボットは重力の方向プロパティを使用しています。
3Dワールドで箱を選択し非表示にします。
重力の方向を使用する場合ツールフレームでロボットに接続したコンポーネントは特定の距離だけ移動します。
コンポーネントが存在する距離は 干渉テストに使用されコンポーネントが干渉するもの全てが 接続する対象です。
[ホーム]タブをクリックします。
ロボットを選択しコンポーネントプロパティでシグナルアクションタブをクリックします。
コンポーネントを3Dワールドに開放する場合、ワールドにリリースにチェックをつけることで3Dワールドに開放することができます。
シグナルアクションを使用する場合重力の方向に注意する必要があります。
出力を1に設定します。
リリースの下に重力の方向が表示されています。
コンポーネントはツールフレームのオブジェクト座標の正の方向に重力の方向で設定した距離移動します。
コンポーネントが干渉する全てのものを対象にコンポーネントを接続します。
円柱の一つを選択します。
円柱の座標がツールフレームの座標であると仮定し下に移動します。
25mm下に移動するため-25と入力します。
永続的に25mm移動するわけではなく円柱が干渉するたび接続します。
円柱がコンベアと干渉しているため箱ではなくコンベアに接続されます。
箱を表示するためにシミュレーションをリセットします。
箱を選択しシミュレーションを一時停止します。
箱を測定します。
重力の方向は25mmである必要はないため1mmに変更します。
シミュレーションをリセットしロボットを選択します。
コンポーネントプロパティのシグナルアクションでアクション設定の出力1に設定し重力の方向を1に設定します。
円柱が箱の内側に接触する設定になっているため変更していきます。
[プログラム]タブをクリックします。
ロボットの状態を変更します。
ロボットが円柱を配置するときシミュレーションを開始したためジョイント構成がロボットに保存されました。
[ジョグ]ウィンドウで初期状態に戻します。
J2は0、J3は90である必要があります。
他のすべてのジョイントは0に変更します。
状態を保存する場合、シミュレーションの設定ボタンをクリックし状態を保存ボタンをクリックします。
現在のジョイント構成でシミュレーションを開始します。
ロボットは移動し停止しました。
シミュレーションを続けるためリセットボタンではなく再生ボタンをクリックします。
円柱と箱が一緒に移動しました。
ロボットで複数のコンポーネントをつかむ方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

ロボットで搬送するワークの個数を変更しよう

ロボットで搬送するワークの個数を、シミュレーション中に変更する方法（マルチグラスプ、ボリュームサイズの検出、検出容積を表示）
（関連動画：ロボットで複数のワークを同時に掴んでみよう）
https://youtu.be/bq0LiF0T-34
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_146.zip

ロボットで搬送するワークの個数を変更する方法について説明します。
本動画は、FAサイトにある「ロボットで複数のワークを同時に掴んでみよう」の関連動画です。
付属ファイル「TransportRobot_before.vcmx」を開きます。
ロボット、ツール、青い円柱、黄色の円柱、コンベアがあります。
シミュレーションを実行します。
ロボットが、ワークを1つ搬送したことがわかります。
シミュレーションをリセットします。
ロボットプログラムを確認します。
ロボットを選択し、[プログラム]タブを開きます。
シミュレーション開始時、[プログラムエディタ]ウィンドウの[Main]が実行されます。
ロボットは、ワークの位置まで移動し、シグナル65をTrueの状態で出力しています。
シグナル65は、Trueの時、ワークをつかみ、Falseの時、ワークを放します。
ロボットは、ワークをつかみ、コンベアの位置まで移動します。
コンベアにワークを放し、ロボットが初期の体勢に戻ると、3秒待機するプログラムとなっています。
ロボットで、複数のワークを同時に搬送する方法を説明します。
ロボットを選択します。
[コンポーネントプロパティ]ウィンドウで、[シグナルアクション]タブをクリックします。
[マルチグラスプ]にチェックを付けることで、ロボットの検出範囲内にある複数のワークを、すべて同時に搬送できます。
シミュレーションを実行します。
ロボットが、すべてのワークを同時に搬送したことがわかります。
シミュレーションをリセットします。
シミュレーション中に、ワークを搬送する個数を変更します。
ロボットで、ワークを2回搬送するため、[プログラムエディタ]ウィンドウの[Main]内にあるステートメントをすべてコピーし、貼り付けます。
1回目の搬送では、ワークを1つ搬送し、2回目の搬送では、複数のワークを同時に搬送します。
[コンポーネントプロパティ]ウィンドウの[マルチグラスプ]の設定を、シミュレーション中に変更します。
[プログラムエディタ]ウィンドウで、1回目の[#Pick]を選択します。
[変数割り当てステートメント]を追加します。
[変数割り当てステートメント]は、変数、またはコンポーネントプロパティに値を割り当てることができます。
今回は、ロボットのコンポーネントプロパティである[マルチグラスプ]に値を割り当てます。
コンポーネントプロパティに値を割り当てる場合、[ステートメントプロパティ]ウィンドウの[ターゲットプロパティ]に「グループ名：：プロパティ名」という形で入力する必要があります。
今回、グループ名は、SignalActions、プロパティ名は、MultiGraspです。
[数式値]にFalseと入力し、1回目の搬送では[マルチグラスプ]を無効にします。
2回目の搬送では、マルチグラスプを有効にするため、[プログラムエディタ]ウィンドウで[Assign SignalActions::MultiGrasp=False]をコピーし、2回目の[#Pick]の下に貼り付けます。
コピーした[Assign SignalActions::MultiGrasp =False]を選択します。
[ステートメントプロパティ]ウィンドウで、[数式値]をTrueに変更します。
ロボットの体勢を初期の状態に戻すため、シミュレーションのリセットボタンをクリックします。
シミュレーションを実行します。
1回目の搬送では、ワークを1つ搬送したことがわかります。
2回目の搬送では、残りのワークをすべて同時に搬送します。
シミュレーションをリセットします。
ロボットで、意図した位置のワークのみ搬送する場合、ワークを検出する範囲を変更する必要があります。
黄色のワークのみ搬送する設定に変更します。
[マニピュレーション]グループの[ジョグ]を選択します。
[ジョグ]ウィンドウで[ツール]の右側にある歯車アイコンをクリックします。
[ツールプロパティ]ウィンドウでは、ワークを検出する範囲を指定する基準点を編集できます。
プルダウンメニューをクリックし、Tool1を選択します。
Tool1の初期位置は、ロボットアームの先端です。
Tool1を吸盤の中心に移動させます。
[ツール]グループの[スナップ]をクリックすることで、選択したものを、別のコンポーネントのクリックした位置に移動させることができます。
上段にある中央の吸盤を選択します。
同様に、Tool2を移動させます。
Tool2の位置は、下段にある中央の吸盤です。
ロボットを選択します。
[コンポーネントプロパティ]ウィンドウで、[アクション設定]を展開します。
[出力]で、1を選択します。
シグナル1がTrueの時、つかむ、Falseの時、リリースを実行します。
つかむ時、ワークを検出する範囲の中心はTool1です。
ワークを検出する範囲のサイズを変更するため、[ボリュームサイズの検出]の[X]に100、[Y]に500、[Z]に100と入力します。
同様に、[出力]2で、[ボリュームサイズの検出]の[X]に100、[Y]に500、[Z]に100と入力します。
設定した範囲を確認する場合、[シグナルアクション]タブで[検出容積を表示]にチェックを付けます。
[検出容積ツール]と[検出容積サイズ]を、[つかむ]の[使用ツール]と[ボリュームサイズの検出]と一致させる必要があります。
[検出容積ツール]は、Tool1、[検出容積サイズ]は、[X]が100、[Y]が500、[Z]が100です。
[出力]1のワークを検出する範囲を確認できます。
[検出容積ツール]をTool2に変更し、[出力]2のワークを検出する範囲を確認します。
ロボットプログラムに、シグナルの値を出力する設定を追加します。
[プログラムエディタ]ウィンドウで、[Main]の[変数割り当てステートメント]をすべて削除します。
出力するシグナルの番号を変更します。
1回目の[Set Out[65]==True]を選択します。
[ステートメントプロパティ]ウィンドウで、[バイナリ出力ステートメント]を1に変更します。
1回目の[Set Out[65]==False]を選択します。
[ステートメントプロパティ]ウィンドウで、[バイナリ出力ステートメント]を1に変更します。
同様に、残りの[Set Out[65]]を[Set Out[2]]に変更します。
[プログラムエディタ]ウィンドウで、[Set Out[2]==True]を[Set Out[1]==True]の下、[Set Out[2]==False]を[Set Out[1]==False]の下に移動させます。
[P6]から下にあるステートメントを、すべて削除します。
シミュレーションのリセットボタンをクリックします。
シミュレーションを実行します。
ロボットが、黄色のワークのみ搬送したことがわかります。
ロボットで搬送するワークの個数を変更する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットにシグナルを接続してみよう（1/2）

ロボットにセンサーやコンベアのシグナルを接続する方法（1回目/全2回）
https://youtu.be/vxRpX1YVayk
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_017.zip

シグナルをロボットに接続する方法について説明します。
ロボットの入力ポート、出力ポートと別のコンポーネントのシグナルを接続します。
シグナルの接続は、[ホーム]タブ、[モデリング]タブ、[プログラム]タブで行うことができます。
[ホーム]タブで、[接続]グループの[シグナル]を、クリックします。
選択したコンポーネントのシグナルエディタが表示されます。
ロボットのシグナルエディタには、「入力」と「出力」という2つの区分があります。
「入力」は、別のコンポーネントから、シグナルの値を受信するための入力用ポート、
「出力」は、シグナルマップに、値を送信するための出力用ポートです。
デジタル信号を扱っているため、コンポーネントには 、ロボットに接続できるブール型のシグナルが必要です。
ブール型のシグナルは、False値またはTrue値を送受信します。
シグナルエディタは、右上のボタンをクリックすると、表示、非表示を切り替えることができます。
センサーコンベアのシグナルエディタを、表示します。
センサーコンベアの「StartStop」シグナルは、パスのオン、オフを制御するシグナルです。
「StartStop」シグナルを、ロボットの「出力」ポートに接続し、
ロボットがパスのオン、オフを、制御できるようにします。
シグナルを接続するために、センサーコンベアの「StartStop」ポートを左クリックし、
ドラッグすると、線が表示されるので、ロボットの「出力」ポートにドラッグします。
緑色のチェックマークが、表示されると、シグナルを出力ポートに、接続できます。
マウスボタンをはなすと、シグナルをロボットの出力に接続することができます。
シグナルを接続している「出力」ポートを変更したい場合は、「0」をダブルクリックし、
「65」を入力し、enterキーを押して確定します。
接続を解除したい場合は、ポート同士をつないでいる線に、カーソルを合わせ左クリックすると、接続が解除されます。
次に、コンポーネントが、コンベアの中心位置に到着したとき、ロボットに通知したい場合、
センサーコンベアの「Sensor Boolean Signal」とロボットの入力ポートを接続します。
「Sensor Boolean Signal」から「入力」までドラッグ＆ドロップし、シグナルを受信できるようにします。
デフォルトでは、ロボットのシグナル1から65は、ワークの把持や解放、ロボットの動作の追跡など、
アクションが事前定義されているため、接続するときはシグナル65以降を使用します。
入力の「0」をダブルクリックし、「65」と入力します。
ロボットとシグナルの接続が完了しました。
動作テストをします。
[プログラム]タブに移動し、ロボットを選択し、
「Main」プログラムに、「バイナリ入力待機ステートメント」を追加します。
ステートメントプロパティの入力ポートを「65」に変更することで、シグナルの接続先を指定し、
入力値はTrueである必要があるため、チェックボックスにチェックをつけます。
入力ポートのシグナルの値がTrueになるまで待機しています。
入力ポートがTrueになったら、ロボットにセンサーコンベアのパスを停止させます。
ロボットから、パスを停止させるシグナルを、送信する必要があります。
「Main」プログラムに、「セットバイナリ出力ステートメント」を追加し、
ステートメントプロパティのバイナリ出力ステートメントを「65」に変更します。
出力値をFalseにしたいので、チェックボックスにチェックをつけません。
シグナルエディタの表示を解除するため、[接続]グループの[シグナル]をもう一度クリックします。
シミュレーションを実行します。
[Feeder]からワークが生成され、パスを流れ、センサーに到達すると、ロボットがパスをオフにするので、
ワークがコンベアの中心位置で停止します。
動作テストについては以上となります。
シグナルをロボットに接続する方法の説明については以上となります。

=================================================================================

ロボットにシグナルを接続してみよう（2/2）

ロボットにセンサーやコンベアのシグナルを接続する方法（2回目/全2回）
https://youtu.be/73QxIuZwL48
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_018.zip

センサーをコンベアに接続し、センサーのシグナルをロボットに接続する方法を説明します。
新規のプロジェクトを準備します。
センサーとコンベアの接続について説明します。
コンポーネントを配置し、コンポーネント同士を接続します。
eカタログの[タイプ別モデル]の下にある[Feeders]を展開し、[Visual Components]をクリックし、[Basic Feeder]を3Dワールドに配置します。
次に、フィーダーにコンベアを接続します。
eカタログから[タイプ別モデル]の下にある[Conveyors]を展開し、[Visual Components]をクリックし、[Conveyor]を3Dワールドに配置します。
次に、[マニピュレーション]グループから、[PnP]を選択し、コンベアをフィーダーに接続します。
表示されている三角形が黄緑色になると、接続が完了したことを表しています。
次に、センサーを追加し、コンベアのパスに接続します。
eカタログの[タイプ別モデル]の下にある[Conveyor Utilities]をクリックし、[Conveyor Sensor]を3Dワールドに配置します。
一部を除き外部センサーは、センサーコンポーネントを別のコンポーネントに接続すると、センサーを、別のコンポーネントのパスに接続することができる、インターフェースが設定されています。
センサーを選択し、コマンド[PnP]を選択した状態で、センサーをコンベア近づけていきます。
三角形が黄緑色になり、接続されたことを確認します。
センサーをコンベア内にあるパスに接続することができ、矢印が青色になっています。
このセンサーは、コンベアの内部センサーではなく、パスに接続する外部センサーです。
接続されたパス上でセンサーをドラッグすると、センサーを別の位置に移動させることもできます。
コンポーネントに、どのような動作設定がされているかを確認するために、[モデリング]タブをクリックします。
センサーを選択すると、コンポーネントグラフのビヘイビアに、[PathInterface]という名称の[1対1接続]があります。
1つのセンサーと、1つのコンベアを接続するので、[1対1接続]を使用しています。
[PathInterface]のプロパティを、確認します。
セクションを展開すると、Processorフィールドがあり、展開すると、センサーの動作と連動するよう設定されています。
センサーと連動するために、Processorフィールドの[Sensor]でComponentPathSensorが選択されています。
[Parent]のチェックボックスには、チェックがついていません。
つまり、センサーはコンベアの子コンポーネントとして、アタッチされています。
次に、コンベアの動作設定を確認するために、コンベアを選択します。
コンポーネントグラフのビヘイビアに、[SensorInterface]という名称の[1対多接続]があります。
[1対多接続]は、複数のコンポーネントと接続することができます。
[SensorInterface]のプロパティを、確認します。
セクションを展開すると、Processorフィールドがあり、展開すると、パスと連携するよう設定され、[Parent]のチェックボックスには、チェックがついています。
これにより、複数のセンサーを、パスに接続することができます。
[1対多接続]の機能を確認するために、コンベアにもう1つセンサーを接続するので、[ホーム]タブに戻り、eカタログから、もう1つコンベアセンサーを配置します。
[PnP]を使用し、センサーを接続して 、パスに2つの外部センサーが接続されている状態にします。
次にロボットを配置し、センサーのシグナルと接続します。
[ホーム]タブに戻り、ロボットを追加します。
eカタログの[タイプ別モデル]の下にある[Robots]を展開し、[Visual Components]をクリックし、[Generic Articulated Robot]を3Dワールドに配置します。
ロボットとセンサーのシグナルを接続するために、[接続]グループの[シグナル]をクリックし、シグナルエディタを表示します。
ロボットのシグナルエディタには、[入力]と[出力]が表示され、2つのセンサーに、それぞれ[BatchReadySignal]、[ResetCounterSignal]、[SensorBooleanSignal]、[TimeLagSignal]が、表示されていることを確認します。
センサーがコンポーネントを検知したとき、ロボットがシグナルを受信するために、[SensorBooleanSignal]とロボットの[入力]を接続します。
[SensorBooleanSignal]横の丸にマウスのカーソルを合わせ、左ボタンをクリックし、ドラッグしたまま、ロボットの[入力]までカーソルを移動させ、緑色のチェックマークが表示されると、シグナルと[入力]を接続できるので、マウスの左ボタンをはなし、ドロップします。
シグナルがロボットの[入力]と接続されました 。
ロボットのシグナル1から64は、把持や解放などの事前定義されたアクションを実行するために、接続済みなので、新しいシグナルを接続するときは、65以降のシグナルを使用します。
入力の0をダブルクリックし、65と入力し、enterキーを押します。
もう1つのセンサーの[SensorBooleanSignal]に対しても、ロボットの[入力]と接続し、ドラッグ＆ドロップで接続し、シグナルを66に変更します。
これで、2つのセンサーのシグナルとロボットのシグナル65と66の接続が完了しました。
センサーの動作確認を行うための設定をします。
もう一度[接続]グループの[シグナル]をクリックし、シグナルエディタを非表示にします。
[プログラム]タブをクリックし、ロボットを選択します。
[Main]プログラムに、[バイナリ入力待機ステートメント]を追加します。
入力ポートを65に変更し、True値を受け取るまで待機したいので、入力値のチェックボックスにチェックをつけます。
1つ目のセンサーがコンポーネントを検知すると、センサーからTrue値が送信され、ロボットが受信するまで待機しています。
トリガー待機にはチェックをつけません。
ロボットを移動させ、その位置を[各軸補間ステートメント]で指定します。
シミュレーションをリセットし、ロボットを初期位置に戻し、シミュレーションを実行します。
1つ目のセンサーがコンポーネントを検知し、ロボットがTrue値を受信し、P1の位置に移動しました。
シミュレーションをリセットします。
2つ目のセンサーがコンポーネントを検知すると、ロボットを別の位置に移動するために、P1の後に、[バイナリ入力待機ステートメント]を追加し、
入力ポートを66に変更し、入力値のチェックボックスにチェックをつけます。
トリガー待機にはチェックをつけません。
2つ目のセンサーがコンポーネントを検知すると、ロボットを別の位置に移動させるので、ロボットを移動させ、[各軸補間ステートメント]を追加します。
シミュレーションをリセットし、ロボットを初期位置に戻し、シミュレーションを実行すると、1つ目のセンサーでコンポーネントを検知し、P1の位置に移動し、2つ目のセンサーでコンポーネントを検知し、P2の位置に移動しました。
シミュレーションをリセットします。
センサーやコンベアの設定を変更する場合、1つ目のセンサーを選択し、[ホーム]タブに戻ります。
センサーのコンポーネントプロパティの[ReactOn]を設定することで、センサーがコンポーネントを検知するタイミングを、変更することができます。
デフォルトの［LeadingEdge］は、コンポーネントの最初のエッジがセンサーに到達したことを検知し、［Origin］に変更すると、コンポーネントの原点がセンサーに到達したことを検知します。
OnSensorActionを[StopPart]や、[StopConveyor]に変更することで、センサーがコンポーネントを検知したとき、コンポーネントまたは、コンベアを停止させることができます。
OnSensorActionを[StopPart]に変更し、シミュレーションを実行します。
1つ目のセンサーでコンポーネントを検知したとき、コンポーネントは停止し、次のコンポーネントが生成され、並んでいきます。
このままの状態では、2つ目のセンサーまでコンポーネントを流すことができません。
コンポーネントを再びスタートさせるためには、センサーにどういった設定がされているか確認してください。
動作確認は、これで終了します。
センサーをコンベアに接続し、センサーのシグナルをロボットに接続する方法の説明については以上となります。

=================================================================================

ロボットにツールを取り付けて設定してみよう

ロボットのアームの先端にツールを取り付けて動かす設定方法
https://youtu.be/J9ahq1Lrzt0
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_024.zip

ロボットにツールを脱着する方法について説明します。
3Dワールドにレイアウトを構築します。
ツールを取り付ける方法の一つとしてPnPを使用しコンポーネントを物理的に接続する方法を説明します。
ツールのコンポーネントを3Dワールドで選択します。
PnPを選択しツールをロボットの先端にドラッグすることで接続できます。
PnPを使用しツールを取り付ける方法についての説明は以上となります。
シミュレーション再生中ロボットにツールを脱着する方法について説明します。
現状ロボットに接続されているツールを取り外しテーブルに配置します。
[プログラム]タブの[ジョグ]を使用し3Dワールドでロボットを選択します。
ロボットプログラムにツールを脱着するためにサブルーチンを追加します。
[プログラムエディタ]で[シーケンスを追加]をクリックし、名前を「DismountTool1」に変更します。
再度[シーケンスを追加]をクリックし名前を「MountTool1」に変更します。
ツールはすでにロボットに取り付けられているため、最初にツールを取り外す「DismountTool1」を設定します。
「DismountTool1」を選択し、ツールをテーブル上に移動させるため ロボットとツールの向きを変更します。
[ジョグ]を使用しロボットをY軸中心に回転させ値を0度にします。
整列ツールのショートカットを使用し、ツールをテーブル上に移動します。
シフトキーを押しながらツールの角をクリックします。
テーブル上までドラッグしシフトキーとマウスボタンを離します。
エスケープキーを押すことで整列を終了し、終了したことが[出力]ウィンドウに表示されます。
移動場所をロボットプログラムに保存します。
「DismountTool1」を選択し直線補間ステートメントを追加します。
シミュレーション再生中にツールを脱着する場合のシグナルでロボットにアクションさせるために、セットバイナリ出力ステートメントを追加します。
ロボットを選択しコンポーネントプロパティからアクション設定を展開します。
ロボットシグナル33から48の16個のツールフレームでは、ツールの脱着のアクションが事前定義されています。
出力の33を選択します。
値がTrueの場合ツールを取り付け、Falseの場合ツールを取り外します。
[ボリュームサイズを検出]を設定することで、ロボットのインターフェース周辺のツールコンポーネントを検出することができます。
現状使用しているロボットのインターフェースはツールです。
インターフェースはツールと接続する位置です。
ツールを取り付ける場合、検出範囲の中心位置にTOOL1が設定されています。
ツールをロボットから取り外す場合重力の方向に距離を設定し、コンポーネントを検出します。
インターフェースはロボットの先端に設定されています。
機能を確認するため[プログラムエディタ]に戻り、セットバイナリ出力ステートメントを選択します。
[ステートメントプロパティ]のバイナリ出力ステートメントに「33」を設定し、ツールを取り外すためFalseの値を出力します。
ロボットを移動し直線補間ステートメントと各軸補間ステートメントを追加します。
各軸補間ステートメントは接近する位置のため、「DismountTool1」の一番上にドラッグで移動します。
ロボットはテーブルに接近しツールを取り外すため加工します。
ツールを取り外し元の位置に戻ります。
シミュレーションをリセットしロボットを初期位置に戻します。
シミュレーションを再生します。
メインルーチンにサブルーチンを呼び出すステートメントを追加しなければ、「DismountTool1」を実行することができません。
メインルーチンを選択します。
コールシーケンスステートメントを追加し、「DismountTool1」を呼び出します。
シミュレーションを再生します。
ロボットが移動しツールを取り外しました。
ロボットに同じツールを取り付ける指示を出すため、シミュレーションをリセットし、[プログラムエディタ]の「MountTool1」に移動します。
「MountTool1」に移動し、各軸補間ステートメントを追加します。
「DismountTool1」に戻り、ツールを取り外す位置を選択します。
「MountTool1」に移動し、直線補間ステートメントを追加し、追加されたP5のポイントをP4のポイントの下にドラッグします。
ツールを取り付けるためセットバイナリ出力ステートメントを追加します。
バイナリ出力ステートメントに33と入力します。
ツールを取り付けるため[出力値]にチェックを入れTrueの値を出力します。
P4のポイントを選択し直線補間ステートメントを追加します。
追加されたP6のポイントをセット バイナリ出力ステートメントの下にドラッグします。
ロボットはテーブルに接近しツールを取り付けるため加工します。
ツールを取り付け、元の位置に戻ります。
シミュレーションをリセットしロボットを初期位置に戻します。
メインルーチンを選択します。
「DismountTool1」の下にコールシーケンスステートメントを追加し「MountTool1」を呼び出します。
シミュレーションを再生し動作を確認します。
ロボットが下降しツールを取り外します。
再度ロボットが下降しツールを取り付けます。
ツールの脱着後コンポーネントを把持するため、ロボットプログラムに新しいサブルーチンを追加します。
シミュレーションをリセットします。
一部のツールはロボットに接続することでロボットと一緒に移動します。
ツールにはシグナルが設定されており、ロボットのシグナルと自動的に接続することができます。
[接続]グループに移動し[シグナル]をクリックするとシグナルエディタが表示されます。
ロボットにはシグナル100が設定されており、ツールにはInSignalとOutSignalが設定されています。
ロボットとツールのシグナルは接続されているため、ツールのジョイントの把持、解放動作を制御することができます。
[接続]グループに戻り[シグナル]を再度クリックし解除します。
[プログラム]タブの[ジョグ]を選択することで、ツールのジョイントの動作を確認することができます。
ツールにカーソルを合わせドラッグします。
ツールがリミットを超えて動作をする場合、シミュレーションをリセットし[リミット]グループの中にある[リミットで停止]にチェックを入れることで、ジョイントに設定されている最小リミットと最大リミットを超えた動作をしません。
ツールを再度操作しリミットを超えないことを確認します。
ロボットはツールのジョイントをインポートし、[ジョグ]ウィンドウにリスト化されています。
ジョイントの最小値が0最大値が20となっておりジョイントを操作することができます。
[コンポーネントプロパティ]にはロボットの6つのジョイントJ1からJ6とツールのジョイントが表示されます。
ステートメントには外部のジョイント値も含まれています。
ロボットに立方体を持ち上げる指示を出します。
[接続]グループの[シグナル]をクリックし、シグナルエディタを表示します。
[プログラム]タブに戻り、[プログラムエディタ]に新しいサブルーチンを追加し名前を「PickCube」に変更します。
ロボットを立方体の上面に移動します。
[ジョグ]ウィンドウの[ベース]で「BASE_1」を選択し[ツール]で「GripperTool1」を選択します。
ロボットのツールフレームを使用し、コンポーネントを外します。
ロボットのツールフレームを「GripperTool1」と同じ位置に移動します。
ツールフレームを表示するため3Dワールドツールバーにあるフレームタイプをクリックし、ロボットツールにチェックを入れます。
3Dワールドでツールフレームが表示されるようになりました。
ロボットには設定済みのツールフレームと、ツールからインポートしたツールフレームがあります。
[ジョグ]ウィンドウに移動し[ツール]で「TOOL[1]」を選択します。
歯車アイコンをクリックしツールプロパティで「TOOL[1]」を編集します。
「TOOL[1]」を「GripperTool1」の位置に移動するため[ツール]グループから[スナップ]を選択します。
[ツールスナップ]ウィンドウでスナップタイプをフレームに設定することで、3Dワールドのフレームの位置に移動することができます。
「GripperTool1」をクリックし「TOOL[1]」が同じ位置に移動したことを確認します。
ツールを取り外した後も設定したツールフレームの位置がロボットの基準点として位置を参照することができます。
ロボットに移動する位置を指示します。
[プログラムエディタ]で「PickCube」を選択し、[ジョグ]ウィンドウに戻り[ツール]を「GripperTool1」に変更します。
[ジョグ]を使用しロボットを選択します。
[スナップ]を使用し立方体の上面に移動します。
現状ツールのみ表示されていますが、立方体の上面をクリックすることでツールとロボットが移動した状態で表示されます。
ツールのジョイント値は最大値です。
ツールのジョイント値を変更し、ジョイントの状態を保存する場合、シミュレーションの開始またはシミュレーションの設定をクリックします。
[状態の保存]をクリックすることで3Dワールドにあるすべてのコンポーネントの状態を保存することができます。
ロボットの初期状態を変更するために、シミュレーションをリセットしてツールのジョイント値を20に変更し、シミュレーションの設定から状態の保存をクリックします。
再度ロボットを立方体の上面に移動するため、[ジョグ]ウィンドウで[ベース]と[ツール]を確認します。
シミュレーションをリセットすることで設定もリセットされるため、「BASE_1」と「GripperTool1」を設定します。
[ツール]グループの[スナップ]を使用しロボットを立方体の上面に移動します。
ツールを閉じる動作を設定します。
「PickCube」を選択し直線補間ステートメントとセットバイナリ出力ステートメントを追加します。
[ステートメントプロパティ]のバイナリ出力ステートメントに100と入力します。
[出力値]にチェックを入れTrueに設定しグリッパーを閉じます。
ツールフレーム1を使用するためバイナリ出力ステートメントに1と入力します。
[出力値]にチェックを入れTRUEに設定し、把持アクションを実行します。
立方体を持ち上げるためロボットを上部に移動します。
立方体を持ち上げる位置と立方体に接近する位置として、直線補間ステートメントと各軸補間ステートメントを追加します。
各軸補間ステートメントはプログラムの先頭に移動します。
ロボットはP9のポイントに移動し立方体を保持するためP7のポイントに移動します。
ツールが把持動作をするため開放動作シグナルはFalse、把持動作シグナルはTrueの値で出力します。
立方体を保持し、持ち上げます。
動作を確認するためシミュレーションをリセットし、メインルーチンにサブルーチンを呼び出します。
メインルーチンを選択し、設定済みのステートメントを削除します。
コールシーケンスステートメントを追加し「PickCube」を選択します。
シミュレーションを再生し動作を確認します。
ツールの把持動作中にロボットが移動していることが確認できます。
把持動作のシグナルを出力するステートメントの下に遅延ステートメントを追加します。
[ステートメントプロパティ]で1秒遅延する設定をします。
シミュレーションを再生し動作を確認します。
立方体に接近し把持動作をした後ロボットは元の位置に戻ったことが確認できます。
ツールが開いた状態となっています。
ロボットがP8のポイントに移動する際にツールが開くため、[プログラムエディタ]でP8のポイントを確認します。
[ステートメントプロパティ]のツールからインポートした外部ジョイントの値が最大値と同じ20に設定されていることが確認できます。
[ジョグ]または[インタラクティブ]を選択しツールのジョイント値を修正します。
[プログラムエディタ]からタッチアップをクリックする、または[ステートメントプロパティ]でステートメントを直接編集し、0に設定します。
シミュレーションをリセットし再生します。
立方体を把持し、持ち上げました。
ツールは閉じた状態となっています。
ロボットプログラムですべてのサブルーチンを実行する設定をします。
シミュレーションをリセットします。
[プログラムエディタ]でメインルーチンを選択し、PickCubeを実行する前にツールを取り外す指示を追加します。
コールシーケンスステートメントを追加し、[ステートメントプロパティ]で「DismountTool1」を設定します。
もう一つのコールシーケンスステートメントを追加し「MountTool1」を設定します。
ツールの取り外し、取り付け、立方体を持ち上げる動作を順に行います。
シミュレーションを再生し動作を確認します。
ロボットはツールの脱着を行い立方体を持ち上げる動作を行いました。
ツールを取り付ける際ツールを開く動作をしていますが、外部ジョイントの特性によるものとなります。
シミュレーションをリセットします。
「DismountTool1」に戻り修正します。
P1、P2、P3のポイントと選択し、[ステートメントプロパティ]で外部ジョイントの値がゼロであることを確認します。
「MountTool1」に移動しP4、P5、P6のポイントと選択していき、外部ジョイントの値を確認します。
P4、P5、P6のポイントを全て選択し、外部ジョイントの値が0に設定されているためツールをドラッグし開いた状態にします。
[E1]に「20」と入力します。
ツールをドラッグし開いた状態にしてタッチアップを使って設定することもできます。
[ステートメントプロパティ]を確認すると外部ジョイントの値は変更できていないため直接変更します。
「DismountTool1」に移動し、P3のポイントを選択します。
外部ジョイントを20に変更します。
P1とP2を選択し外部ジョイントを20に変更します。
動作を確認します。
ツールの脱着を行い、立方体を持ち上げる動作を行いました。
ツールを取り付ける際ツールを開く動作をしなくなったことが確認できます。
3Dワールドで使用しているようなツールをモデル化する場合、[モデリング]タブのウィザード機能を使用することでツールのモデリングができます。
[追加]グループの[ウィザード]を展開し[先端]をクリックすることでツールに必要な設定が自動で追加されます。
シミュレーション中ロボットに複数のツールを取り付け取り外しをする方法を説明します。
シミュレーションをリセットします。
[プログラム]タブに移動し、別のツールを取り外しをするためのサブルーチンを追加し、名前を「DismountTool2」に変更します。
同様にツールを取り付けるための サブルーチンを追加し名前を「MountTool2」に変更します。
2つ目のツールを取り付けるための設定をします。
メインルーチンを変更していきます。
「MountTool1」を呼び出すステートメントを削除し、コールシーケンスステートメントを追加します。
[ステートメントプロパティ]で「MountTool2」に設定します。
「MountTool2」にステートメントを追加します。
停止ステートメントを追加し、シミュレーションを停止できるようにします。
シミュレーションを再生します。
ロボットは1つ目のツールを取り外し、シミュレーションは停止します。
2つ目のツールを取り付けるためにロボットの位置を設定します。
「MountTool2」を選択しロボットを移動します。
[ツール]グループの[スナップ]を選択し2つ目のツールの位置に移動します。
2つ目のツールを取り付けるためツールフレーム2を使用します。
直線補間ステートメントとセットバイナリ出力ステートメントを追加します。
[ステートメントプロパティ]のバイナリ出力ステートメントに34と入力し、[出力値]にチェックを入れます。
シグナル34はTRUE値を出力することで、ツールフレーム2を中心とする検出範囲内にあるツールを取り付けます。
ロボットを上部に移動し、各軸補間ステートメントと直線補間ステートメントを追加します。
各軸補間ステートメントは接近する位置となるため、「MountTool2」の先頭にドラッグします。
ロボットはツールを取り付けるため加工しツールを取り付け元の位置に戻ります。
停止ステートメントは削除します。
シミュレーションをリセットし再生します。
ロボットは1つ目のツールを取り外し2つ目のツールを取り付けたことが確認できます。
2つ目のツールを取り外すため「DismountTool2」を設定します。
「MountTool2」のP12のポイントを選択し「DismountTool2」に移動します。
各軸補間ステートメントを追加します。
「MountTool2」に戻りP10のポイントを選択し「DismountTool2」に移動します。
直線補間ステートメントを追加します。
直線補間ステートメントを各軸補間ステートメントの下にドラッグします。
セットバイナリ出力ステートメントを追加します。
バイナリ出力ステートメントを34に設定し、[出力値]にチェックを入れないことで、ツールフレーム2に取り付けられたツールを取り外します。
P13のポイントを選択し直線補間ステートメントを追加します。
セットバイナリ出力ステートメントの下にドラッグします。
2つ目のツールを取り付けた後ツールを取り外す動作を行うため、「DismountTool2」をメインルーチンに呼び出します。
コールシーケンスステートメントを追加し[ステートメントプロパティ]に「DismountTool2」を選択します。
シミュレーションをリセットし再生します。
1つ目のツールを取り外し2つ目のツールを脱着することが確認できます。
ロボットにツールを脱着する方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

ロボットに外部軸を接続しよう

ロボットに外部軸を接続して、外部軸の動作を制御する方法
https://youtu.be/OmgR7DrvqAk
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_111.zip

ロボットに外部軸を接続する方法を説明します。
[Connect External Axis to Robot.vcmx]をダウンロードし、開きます。
ロボットとコンポーネントを接続するには、物理的に接続する方法とリモートで接続する方法があります。
物理的に接続する方法を説明します。
ロボットと台座には、物理的な接続を可能にする1対1のインターフェースが備わっています。
[ホーム]タブを開きます。
[マニピュレーション]-[PnP]を選択します。
ロボットを選択し、台座に接続します。
ロボットが台座のノードに接続されており、親子階層になっているため、台座を動かすと、一緒にロボットも動きます。
[プログラム]タブを開きます。
[リミット]-[リミットで停止]のチェックボックスが選択されていないことを確認します。
[マニピュレーション]-[ジョグ]が選択された状態で、台座をプラットフォームに沿ってドラッグして、ロボットと一緒に動かします。
台座がプラットフォームからはみ出ると、[ジョグ]ウィンドウ-[ジョイント]-[Robot Floor Track]-[EJ_X]の値がマイナス値となり、バー部分が赤く表示されます。
台座がプラットフォームからはみ出ないようにしたい場合は、[リミットで停止]のチェックを入れます。
シミュレーションをリセットします。
リモートで接続する方法を説明します。
[ホーム]タブを開きます。
[マニピュレーション]-[PnP]を選択します。
ロボットは、物理的な方法でポジショナに接続できないため、接続エディタを使用して、リモートで接続します。
ロボットを選択します。
[接続]-[インターフェース]を選択し、接続エディタを表示します。
接続エディタ内に接続可能なコンポーネントとインターフェースが表示されます。
今回は、ポジショナに接続するため、"Connect Workpiece Positioner"のポインタをドラッグしてポジショナに近づけます。
ポジショナが黄色でハイライトされているのがわかります。
これは、ロボットのインターフェースをポジショナのノードに接続できることを意味しています。
ロボットから出ている線をポジショナ上でドロップすると、自動的に接続されます。
接続を解除したい場合は、線をクリックします。
"Connect Workpiece Positioner"は、ポジショナのジョイントの値を入力するように設定されています。
ポジショナから出力されたジョイントの値を1対1のインターフェースで、ロボットに入力します。
ロボットとポジショナは一対一で接続してください。
1つのロボットに複数の異なるポジショナを接続することはできません。
ロボットをプログラムします。
[プログラム]タブを開きます。
[マニピュレーション]-[ジョグ]を選択します。
台座を任意の位置まで+X軸方向にドラッグして、ロボットと台座を動かします。
ターンテーブルがF側を向くようポジショナを動かします。
ターンテーブルを回転します。
[サブプログラム]-[Main]に[各軸補間ステートメント]を追加します。
[各軸補間ステートメント]は、ロボットの位置を記録し、ジョイントの値を補間して動かすことができます。
[ステートメントプロパティ]ウィンドウを確認すると、E1、E2、E3があります。
E1、E2、E3の値にどのジョイントが割り当てられているのかを確認します。
シミュレーションをリセットします。
再度ターンテーブルがF側を向くようにポジショナを動かし、ターンテーブルを回転します。
PTP P1が選択された状態で、[プログラムエディタ]-[タッチアップ]を選択します。
タッチアップは、選択したポジションのモーションを更新します。
[ステートメントプロパティ]ウィンドウを確認すると、E1の値が0、E2とE3の値が変化しています。
ポジショナだけを動かしたことで、ポジショナの値が変化したため、E1がロボット、E2とE3がポジショナだということがわかります。
台座を任意の位置まで+X軸方向にドラッグして、ロボットと台座を動かします。
PTP P1が選択された状態で、[プログラムエディタ]-[タッチアップ]を選択します。
[ステートメントプロパティ]ウィンドウを確認すると、E1のみ値が変化したため、E1がロボットということがわかります。
シミュレーションをリセットします。
シミュレーションを実行します。
ロボットとポジショナが初期状態から指定した位置に向かって動いていることがわかります。
ロボットに外部軸を接続する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットのジョイントをPythonで動かそう(1/2)

Pythonスクリプトを使用して、ロボットのジョイントや外部軸（レール、ロボットツール）を動かす方法（Joints、ExternalController）
https://youtu.be/IcjG6mDOVJY
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_162_p1.zip

ロボットのジョイントをPythonで動かす方法を説明します。
パート1では、Pythonスクリプトでロボットのジョイントと外部軸を取得し、動かします。
[Internal and External Joints_before.vcmx]をダウンロードし、開きます。
3Dワールドに、ロボットとレールが配置されています。
ロボットツールを追加します。
eカタログの[タイプ別モデル]-[Robot Tools]-[Visual Components]を開きます。
[Parametric Box Gripper]を配置します。
ボックスグリッパーをロボットの外部軸として動かせるように設定します。
[モデリング]タブを開きます。
[追加]-[ウィザード]-[先端]を選択します。
[先端]は、ロボットツールの制御に必要な設定を追加します。
[先端]ウィンドウの[コントロール]で、ロボットツールの先端をコントロールする方法を選択できます。
[先端]は、[None]、[IO]、[ExternalAxis]、[IO/ExternalAxis]を選択できます。
[None]は、動作が設定されません。
[IO]は、入出力信号で動作します。
[ExternalAxis]は、ロボットの外部軸で動作します。
[IO/ExternalAxis]は、IOとExternalAxisの両方で動作します。
今回は、ロボットの外部軸で制御するため、[ExternalAxis]を選択し、[適用]ボタンをクリックします。
[出力]ウィンドウを確認すると、設定が追加されたことがわかります。
[閉じる]ボタンでウィンドウを閉じます。
ロボットにボックスグリッパーを接続します。
[ホーム]タブを開きます。
[マニピュレーション]-[PnP]が選択された状態で、ボックスグリッパーをロボットに接続します。
[コンポーネントプロパティ]ウィンドウのRyを0にし、ボックスグリッパーを回転します。
ロボットの外部軸にボックスグリッパーが追加されていることを確認します。
[プログラム]タブを開きます。
ロボットを選択します。
[ジョグ]ウィンドウを確認すると、ジョイントにロボットのジョイントであるJ1～J6が設定されています。
外部軸として、レールとボックスグリッパーが設定されていることがわかります。
パイソンスクリプトを使用して、ジョイントを制御します。
[モデリング]タブを開きます。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
OnSignal関数とOnRun関数は不要なため、削除します。
comp = getComponent()と記述し、Pythonスクリプトを設定しているコンポーネントを取得します。
robotController = comp.findBehaviour()と記述し、指定したビヘイビアの情報を取得します。
今回はロボットのジョイントを制御するため、ロボットコントローラの情報を取得します。
[コンポーネントプロパティ]ウィンドウ]を確認すると、ロボットコントローラはCRという名前のため、CRと記述します。
print robotControllerと記述し、ロボットコントローラの情報を[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、ロボットコントローラの情報が表示されています。
ロボットコントローラの名前が分からない場合は、タイプで探すことができます。
findBehaviourをfindBehavioursByTypeに変更します。
CRを削除し、VC_ROBOTCONTROLLERと記述します。
VC_ROBOTCONTROLLERは、コンポーネント内のロボットコントローラを全て取得できます。
今回は、ロボットコントローラが1つしかないため、0番目のコントローラを取得します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、ロボットコントローラの情報が表示されています。
ロボットのジョイントを取得します。
print robotControllerにJointsを追記します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、ジョイントの情報が表示されています。
[プログラム]タブを開きます。
ロボットが選択された状態で、[ジョグ]ウィンドウを確認します。
ロボットのジョイントが6つと、外部軸が2つあるため、合計で8つのジョイントがあります。
[出力]ウィンドウには8つのジョイントが表示されているため、全てのジョイントが取得できていることがわかります。
print関数にlenを追記し、リスト内の個数を表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、ロボットのジョイントが8つ取得できていることがわかります。
ロボットの6つのジョイントを取得し、リストに格納します。
internal_joints = []と記述し、空のリストを作成します。
for joint in robotController.Joints:と記述し、全てのジョイントをjointという変数に代入します。
if joint.ExternalController == None:と記述します。
ExternalControllerはジョイントの外部コントローラを取得します。
ジョイントの外部コントローラがNone、つまり、外部軸ではないときを条件にします。
internal_joints.append(joint)と記述し、外部軸以外のジョイントをリストに追加します。
print関数の()の中をinternal_jointsに変更し、ロボットのジョイントが表示されるようにします。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、ロボットのジョイントが6つ取得できていることがわかります。
ロボットの2つの外部軸を取得し、リストに格納します。
external_joints = []と記述し、空のリストを作成します。
for joint in robotController.Joints:と記述し、全てのジョイントをjointという変数に代入します。
if joint.ExternalController != None:と記述し、外部コントローラがNoneではないとき、つまり、外部軸のときを条件にします。
external_joints.append(joint)と記述し、外部軸のジョイントをリストに追加します。
print関数の()の中をexternal_jointsに変更し、ロボットの外部軸が表示されるようにします。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、ロボットの外部軸が2つ取得できていることがわかります。
外部軸の情報をリストとして表示し、外部軸が取得できていることを確認します。
print joint.ExternalControllerと記述し、外部軸のリストを[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、ロボットの外部軸のコントローラの情報が2つ表示されています。
結果が確認できたため、print関数をコメントアウトします。
for文の代わりに関数を作成し、ロボットのジョイントの取得を簡略化します。
ロボットの6つのジョイントを取得します。
def getInternalJointsInRobot:と記述し、getInternalJointsInRobotという関数を作成します。
引数をrcにします。
rcにはロボットコントローラの情報を入力します。
return list()と記述し、結果をリストで返します。
外部軸は不要なため、filter関数を使用して、指定した条件に合う要素を抽出します。
外部軸以外の6つのジョイントのみ抽出するため、(lambda x: x.ExternalController == None, rc.Joints)と記述します。
print関数の()の中をgetInternalJointsInRobotに変更し、関数の結果を[出力]ウィンドウに表示します。
ロボットコントローラのジョイントを取得するため、robotControllerと記述します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、ロボットのジョイントが6つ取得できていることがわかります。
同様に、ロボットの2つの外部軸を取得します。
関数をコピーし、貼り付けます。
外部軸を取得するため、関数名のInternalをExternalに変更します。
=を!に変更し、外部コントローラがNoneではないとき、つまり、外部軸のときを条件にします。
print関数の()の中をgetExternalJointsInRobotに変更し、関数の結果を[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、ロボットの外部軸が2つ取得できていることがわかります。
結果が確認できたため、print関数を削除します。
ロボットの6つのジョイントの値を取得します。
for joint in getInternalJointsInRobot(robotController):と記述し、ロボットの6つのジョイントをjointという変数に代入します。
print jointと記述し、6つのジョイントを[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、ロボットのジョイントが6つ取得できていることがわかります。
print関数に.CurrentValueを追記し、6つのジョイントの現在値を表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、0.0、90.0、0.0と表示されています。
[ジョグ]ウィンドウを確認すると、J3は90、J3以外は0になっています。
[出力]ウィンドウは、同じ内容のメッセージが連続して出力される場合、表示が省略されます。
J1とJ2が0のため、まとめて0.0、J3が90のため90.0、J4～J6は0のため、まとめて0.0と表示されていることがわかります。
ロボットのジョイントの数値を全て0にして、現在のロボットの姿勢を変更します。
printを削除し、=0を追記します。
コンパイルボタンをクリックします。
[ジョグ]ウィンドウを確認すると、J1～J6が全て0になっていますが、ロボットの姿勢が変わっていません。
ジョイントの値は内部的には変更されていますが、3Dワールドに反映されていません。
3Dワールドに反映するには、3Dワールドを再描画する必要があります。
getApplication().render()と記述し、3Dワールドを再描画します。
コンパイルボタンをクリックします。
3Dワールドを確認すると、ロボットの姿勢が変わっていることがわかります。
レールとボックスグリッパーのジョイントの数値を変更します。
レールとボックスグリッパーは外部軸のため、getExternalJointsInRobot関数を使用します。
for文のInternalをExternalに変更します。
レールとボックスを1000.0にします。
コンパイルボタンをクリックします。
3Dワールドを確認すると、レールが移動し、ボックスグリッパーが開いています。
[ジョグ]ウィンドウを確認すると、レールとボックスグリッパーが1000になっています。
ボックスグリッパーはスライダーが赤くなっているため、制限を超えていることがわかります。
シミュレーションをリセットします。
Pythonスクリプトでロボットのジョイントと外部軸を取得し、動かす方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットのジョイントをPythonで動かそう(2/2)

Pythonスクリプトを使用して、ロボットのジョイントや外部軸（レール、ロボットツール）を動かす方法（Dof、findNode、Children）
https://youtu.be/uGj9dXqCmfM
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_162_p2.zip

ロボットのジョイントをPythonで動かす方法を説明します。
パート1では、Pythonスクリプトでロボットのジョイントと外部軸を取得し、動かしました。
パート2では、Pythonスクリプトでロボットの各ジョイントのプロパティを取得し、動かします。
[Internal and External Joints_Part1_after.vcmx]をダウンロードし、開きます。
ロボットの各ジョイントのプロパティを取得します。
プロパティを取得する前に、各ジョイントの構成を確認します。
ロボットを選択します。
[モデリング]タブを開きます。
[コンポーネントグラフ]ウィンドウのプロパティとビヘイビアをオフにします。
プラスボタンを選択し、ツリーを展開します。
ルートノードには、J1～J6とロボットツールを取り付けるためのmountplateがあります。
J1を選択します。
[リンクプロパティ]ウィンドウを確認すると、ジョイントプロパティの項目があります。
名前や使用しているコントローラ、初期値などのプロパティが表示されています。
パイソンスクリプトを使用して、ジョイントプロパティの情報を取得します。
[コンポーネントグラフ]ウィンドウのプロパティとビヘイビアをオンにします。
パイソンスクリプトを開きます。
print comp.Dofと記述し、ジョイントプロパティを[出力]ウィンドウに表示します。
Dofは、ノードのジョイントプロパティを取得できます。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、Noneと表示されています。
comp.Dofと記述すると、コンポーネントのルートノードのプロパティを取得できますが、ルートノードにはジョイントがありません。
そのため、Noneと表示されます。
J1のジョイントプロパティを取得します。
compとDofの間にfindNode("J1")を追記し、J1のジョイントプロパティを[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、ジョイントプロパティの情報が表示されています。
J1のジョイントの値を変更します。
Dofの後ろに.VALUE = 90を追記し、J1のジョイントを90にします。
[出力]ウィンドウに表示する必要はないため、printを削除します。
コンパイルボタンをクリックします。
3Dワールドを確認すると、ロボットのJ1が90度回転していることがわかります。
[コンポーネントグラフ]ウィンドウのJ1を選択します。
[リンクプロパティ]を確認すると、J1が90になっています。
シミュレーションをリセットし、ロボットの位置を戻します。
ロボットの子ノードであるJ1を取得します。
最後の2行は不要なため、削除します。
print comp.Childrenと記述し、ロボットの子ノードを[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、1つのノードの情報が表示されています。
Childrenは、親の直接の子ノードを取得するため、RV-13FLの子ノードであるJ1のみ取得されています。
Childrenに[0].Nameを追記して、J1が取得されているか[出力]ウィンドウに名前を表示して確認します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、J1と表示されています。
J1～mountplateまでの全ての子ノードを取得します。
全ての子ノードを取得するには、各親のノードに対してChildrenを適用する必要があります。
つまり、J1にChildrenを適用してJ2を取得、J2にChildrenを適用してJ3を取得という処理を行います。
print関数を削除します。
外部軸の数値変更は不要なため、コメントアウトします。
def getAllNodesInComponent()と記述し、getAllNodesInComponentという関数を作成します。
第一引数にcompと記述し、処理をしたい対象のコンポーネントを指定します。
第二引数にnodes=[]と記述し、nodesを格納するためのリストのデフォルト値を空にします。
第三引数にincludeRootNode=Falseと記述し、ルートノードをデフォルトでリストに含めない設定にします。
if not nodes: nodes =[]と記述し、nodesがない場合、空のリストを作成します。
if includeRootNode == True:nodes.append(comp)と記述し、includeRootNodeがTrueの場合、ルートノードをnodesリストに追加します。
それぞれの親ノードから子ノードを取得します。
for node in comp.Children:と記述し、指定したコンポーネントから子ノードをnodeという変数に代入します。
if node.Component == comp.Component:と記述し、子ノードが指定したコンポーネント内に存在するか確認します。
nodes.append(node)と記述し、指定したコンポーネントに存在する場合、nodesのリストに子ノードを追加します。
取得した子ノードが別のコンポーネント内にある場合は、リストに追加されません。
if node.Children:と記述し、取得した子ノードが更に子ノードを持っているか確認します。
getAllNodesInComponent(node, nodes)と記述し、子ノードを持っている場合は、nodeとnodesの値を使用して、関数を再帰的に呼び出します。
子ノードがなくなるまで、関数を再帰的に呼び出し、処理を繰り返します。
return nodesと記述し、最後に取得したリストを返します。
関数の結果を[出力]ウィンドウで確認します。
print len(getAllNodesInComponent)と記述し、リストの数を[出力]ウィンドウに表示します。
ロボットの子ノードを取得したいため、compを指定します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、リストに7つのノードがあることがわかります。
[コンポーネントグラフ]ウィンドウでノードの数を確認すると、J1～J6とmountplateの合計7つのノードがあります。
つまり、7つのノードが取得できていることがわかります。
ルートノードをリストに追加します。
print関数にincludeRootNode=Trueを追記します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、リストに8つのノードがあることがわかります。
ノードはルートノードを含めて8つあるため、全てのノードが取得できたことがわかります。
全てのノードのジョイントプロパティを取得します。
def getAllDofInComponent:と記述し、getAllDofInComponentという関数を作成します。
引数をcompにします。
list = map(lambda x: x.Dof, getAllNodesInComponent(comp))と記述します。
map関数は、リストの各値に対して、指定した関数を適用することができます。
今回は、getAllNodesInComponent(comp)で取得したリストに対して、lambda x: x.Dofを適用します。
つまり、リスト内の各ノードに対して、プロパティオブジェクトを取得します。
return filter(lambda x: x != None, list)と記述し、ジョグプロパティがNoneでないものを抽出し、リストとして返します。
mountplateは、ロボットツールを取り付けるためのフレームのため、ジョイントプロパティを所持していません。
filter関数を使用して、lambda x: x != Noneにしない場合、リストにmountplateのNoneが入ってしまいます。
そのため、filter関数でジョイントプロパティの情報のみ抽出し、リストに格納します。
print関数をgetAllDofInComponent(comp)に変更し、ジョイントプロパティの情報を[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、ジョイントプロパティの情報が6つ表示されています。
mountplateはNoneのため、[出力]ウィンドウに表示されていません。
また、getAllNodesInComponentでルートノードがデフォルトでFalseになっているため、RV-13FLの情報はリストに入っていません。
J1～J6までの全てのジョイントプロパティが取得できたことがわかります。
Noneも取得したい場合は、returnの!=を==に変更します。
もしくは、filter関数を使用せず、単にreturn listと記述することで、Noneもリストに代入できます。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、Noneが表示されています。
結果が確認できたため、Noneを表示しないように元のソースコードに戻します。
return listを削除します。
return filterのコメントアウトを外し、==を!=に戻します。
listとreturn filterの2行を1つのソースコードにまとめて記載できます。
2行をコメントアウトします。
return filterをコピーし、貼り付けます。
listを削除し、代わりにmap関数をコピーして貼り付けます。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、ジョイントプロパティの情報を6つ取得していることがわかります。
取得したジョイントプロパティを使用して、ジョイントの値を全て0にします。
print関数は不要なため、削除します。
for dof in getAllDofInComponent(comp):と記述し、ジョイントプロパティをdofという変数に代入します。
dof.VALUE = 0と記述し、値を全て0にします。
getApplication().render()と記述し、3Dワールドを再描画します。
コンパイルボタンをクリックします。
3Dワールドを確認すると、ジョイントが全て0になっていることがわかります。
シミュレーションをリセットします。
Pythonスクリプトでロボットの各ジョイントのプロパティを取得し、動かす方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットのプログラムを使用し、統計情報を表示しよう(1/2)

ロボットの動作の条件分岐のElseIfの使用方法と、統計情報の設定方法
https://youtu.be/iaHuE8ZdoJY
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_119.zip

ロボットのプログラムを使用し、統計情報を表示する方法を説明します。
ワークの数をカウントするロボットプログラムを作成し、ロボットのステータスをグラフで表示します。
動画内で使用するGeminiのファイルをダウンロードします。
ファイル名は、[Elself and Set state statements in Robot Programing_before.vcmx]です。
セルグラフタブを開きます。
[セルグラフ]ウィンドウを確認すると、コンベア、コンベアのセンサー、ロボット、フィーダーが配置されていることがわかります。
シミュレーションを実行すると、フィーダーがコンベア上を流れます。
シミュレーションをリセットします。
ロボットプログラムを使用して、ワークがコンベア上のセンサーを通過したときに個数をカウントするため、ロボットとセンサーのシグナルを接続します。
[接続]-[シグナル]を選択します。
ロボットをクリックすると、使用されているシグナルが表示されます。
ワークが通過したことをロボットに通知するため、[Conveyor Sensor]の[SensorBooleanSignal]と[RV-7HRL]の[入力]を接続します。
入力シグナルは100を使用するため、0を100に変更します。
[プログラム]タブを開きます。
ワークがセンサーを通過したときに、センサーがロボットに通知し、[出力]ウィンドウにメッセージを表示するようプログラムを作成します。
ワークが通過したという内容を3個目まで表示し、3個通過したら、ワークがストップするという内容を表示し、シミュレーションが一時停止するようにします。
ロボットのステータスを可視化するため、統計も設定します。
[プログラムエディタ]ウィンドウの[サブプログラム]-[Main]にプログラムを作成していきます。
ワークがセンサーを通過するまで、プログラムを待機します。
ワークがセンサーを通過するときに入力シグナルの100にTrueが送信されるため、入力シグナルの100がTrueになるまで待機するようにします。
[バイナリ入力待機ステートメント]を追加します。
[ステートメントプロパティ]の[入力ポート]を100にします。
[入力値]にチェックを入れて、Trueにします。
[トリガー待機]は、特定の動作などをトリガーとして、処理を実行する場合に使用します。
今回は、トリガーで処理をしないため、チェックを外します。
ロボットのステータスの統計情報を設定します。
[状態の設定]を追加します。
ワークがセンサーを通過する前の状態を取得するため、[State]を[Wait IN[100]]の前に移動します。
[ステートメントプロパティ]ウィンドウの[Statistics]で[Statistics]を選択します。
ワークがセンサーを通過するまで、待機している状態のため、[State]で[Idle]を選択します。
アイドルは、何も処理を行っておらず、すぐ使用できるよう待機している状態のことを言います。
ワークをカウントするための変数を用意します。
[サブプログラム]-[Main]を選択します。
[ルーチンプロパティ]で新規変数を追加します。
整数でワークの個数をカウントするため、[整数変数]を選択します。
[名称]にcountと入力します。
[値]は0のままにします。
ワークを3個目までカウントし、3個通過したらワークがストップするよう条件を分岐します。
[IFステートメント]を追加します。
デフォルトでは、ThenとElseで2つの条件に分岐できます。
今回は、ワークを3個までカウントする条件と、3個通過したらストップする条件の4つの条件に分岐する必要があります。
[If True:]にマウスオーバーすると、右に＋ボタンが表示されます。
+ボタンを2回クリックし、条件分岐を2つ追加します。
ワークが最初にセンサーを通過したとき、つまり、カウントが0の状態でワークがセンサーを通過した場合を条件にします。
[If True:]を選択し、[ステートメントプロパティ]の[コンディション]で条件を設定します。
[コンディション]にcount==0と入力します。
Thenで、カウントが0の状態でワークがセンサーを通過した場合の処理を記述します。
[状態の設定]を追加し、ロボットのステータスの統計情報を設定します。
[ステートメントプロパティ]ウィンドウの[Statistics]で[Statistics]を選択します。
ワークをカウントする処理を行うため、[State]で[Busy]を選択します。
ビジーは、何かしらの処理で忙しいため、他の処理を受け付けられない状態のことを言います。
[出力]ウィンドウにメッセージを表示させるため、[プリントステートメント]を追加します。
[ステートメントプロパティ]ウィンドウのメッセージにFirst Part Arrived!と記述し、1個目のワークが通過したことを表示します。
カウントを1にするため、[変数割り当てステートメント]を追加します。
[ステートメントプロパティ]ウィンドウの[ターゲットプロパティ]に値を代入したい変数を入力します。
カウント変数に値を代入するため、countと入力します。
[数式値]にcount+1と入力し、カウントを1にします。
次の処理に移る前に、処理時間に余裕を持たせるため、2秒待機させます。
[遅延ステートメント]を追加します。
[ステートメントプロパティ]ウィンドウの[遅延]に2を入力します。
Elseifで、カウントが1の状態でワークがセンサーを通過した場合の処理を記述します。
[プロパティ]ウィンドウのConditionにcount==1と入力します。
Thenと同じ処理をするため、State BusyからDelay 2sまでをコピーします。
<empty>にペーストします。
プリントステートメントのメッセージを変更します。
Printを選択します。
[ステートメントプロパティ]ウィンドウのメッセージにSecond Part Arrived!と記述し、2個目のワークが通過したことを表示します。
count変数には+1が入力され、カウントが2になるため、そのままにします。
Elseifで、カウントが2の状態でワークがセンサーを通過した場合の処理を記述します。
[プロパティ]ウィンドウのConditionにcount==2と入力します。
<empty>に再度ペーストします。
プリントステートメントのメッセージを変更します。
Printを選択します。
[ステートメントプロパティ]ウィンドウのメッセージにThird Part Arrived!と記述し、3個目のワークが通過したことを表示します。
count変数には+1が入力され、カウントが3になるため、そのままにします。
ワークが3個目までカウントされるため、Elseでシミュレーションが一時停止する処理を記述します。
[出力]ウィンドウにメッセージを表示させるため、[プリントステートメント]を追加します。
[ステートメントプロパティ]ウィンドウのメッセージにStop!と記述し、ワークがストップしたことを表示します。
シミュレーションを一時停止するため、[停止ステートメント]を追加します。
シミュレーションを実行します。
1個目のワークがセンサーを通過後、[出力]ウィンドウに1個目が到着したことが表示されます。
2個目以降は、[出力]ウィンドウにメッセージが表示されていません。
[サブプログラム]を確認すると、処置中を表す緑の丸も表示されず、プログラムが処理されていないことがわかります。
ループ処理がされていないため、最初のThenのみ処理され、Elseifの処理が飛ばされている状態になっています。
シミュレーションをリセットします。
ループ処理を設定します。
3Dワールドのロボットをクリックします。
[コンポーネントプロパティ]ウィンドウの[Executor]タブを開きます。
ルーピングにチェックを入れます。
シミュレーションを実行します。
1個目のワークがセンサーを通過後、[出力]ウィンドウに1個目が到着したことが表示されます。
続いて、2～3個目のワークがセンサーを通過したことが表示されます。
3個目のワークが到着後、シミュレーションが停止します。
シミュレーションをリセットします。
条件分岐のプログラムが完了後、ワークがセンサーから離れるまで待機します。
[バイナリ入力待機ステートメント]を追加します。
[ステートメントプロパティ]の[入力ポート]を100にします。
[入力値]にチェックは入れず、Falseにします。
ロボットのステータスのパーセンテージをグラフで可視化します。
[ホーム]タブを開きます。
[統計情報]を選択します。
[統計情報]ウィンドウが表示されます。
レイアウトは、1列 1行の標準ダッシュボードが選択された状態で、クリエイトボタンをクリックします。
ロボットを選択します。
[テンプレートチャート]の[ステータス]を選択すると、グラフが作成され、Idle、Busyなどの状態に関する項目が反映されます。
[ステータス]ウィンドウの[データの期間]で、データの表示時間を指定します。
[Last Interval]は、前回と今現在の間隔の状態を表示します。
[シミュレーション作動]は、シミュレーション実行時間の全体における状態の割合を表示します。
今回は、[シミュレーション作動]を選択します。
統計情報を1秒ごとに取るため、[統計情報]の[間隔]に1を入力します。
シミュレーションを実行すると、プログラムで設定した状態に合わせて、グラフの状態も表示されます。
ロボットのプログラムを使用し、統計情報を表示する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットのプログラムを使用し、統計情報を表示しよう(2/2)

ロボットの稼働状況を統計情報で設定し、グラフ表示する方法
https://youtu.be/6eBlIG5MGp4
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_119_p2.zip

ロボットの稼働状況をグラフで表示する方法について説明します。
本動画は、「ロボットのプログラムを使用し、統計情報を表示しよう」の続きから説明します。
付属ファイル「Elself and Set state statements in Robot Programing_after.vcmx」を開きます。
[統計情報]グループの[統計情報]をクリックします。
ロボットの状態をグラフで表示できます。
シミュレーションを実行します。
センサーがワークを検知した時、ロボットは稼働状態になり、グラフではBusyの割合が増加します。
[出力]ウィンドウに、センサーがワークを検知したことが表示されます。
センサーが4つ目のワークを検知すると、シミュレーションは停止します。
シミュレーションをリセットします。
[統計情報]ウィンドウに、ロボットの稼働状況のグラフと、状態の割合を比較するグラフを追加します。
グラフを表示するため、統計情報を取得します。
eカタログに登録されているロボットには、デフォルトで、統計情報を収集する設定がされています。
ロボットを選択し、[モデリング]タブを開きます。
[コンポーネントグラフ]ウィンドウの[RV-7FRL]、[ビヘイビア]と展開します。
[Statistics]を選択します。
Statisticsは、シミュレーション再生中に、同じコンポーネント内の、ビヘイビアから統計情報を収集できます。
[プロパティ]ウィンドウには、収集する統計情報が表示されています。
Statisticsには、コンポーネントの状態を設定することもできます。
状態は、Warmup、Break、Idle、Busy、Blocked、Broken、Repair、Setupの8種類です。
Warmupなどの意味は、動画「統計情報を表示してみよう」を参照してください。
8種類の状態が表示されていない場合、[デフォルト状態をクリエイト]をクリックすることで、自動的に追加できます。
ロボットの現在の状態は、[プログラム]タブで変更することができます。
[プログラム]タブを開きます。
[プログラムエディタ]ウィンドウの[State Idle]を選択します。
[状態の設定]ステートメントで、ロボットの状態をIdleに設定しています。
[ステートメントプロパティ]ウィンドウで、Statisticsと状態を指定できます。
動作の合間に[状態の設定]ステートメントを設定することで、ロボットの状態を変更しています。
[ホーム]タブを開きます。
グラフを追加するため、[統計情報]ウィンドウの[レイアウトを変更]をクリックします。
表示するグラフのレイアウトを変更できます。
[2列2行概要ダッシュボード]を選択し、[変更]をクリックします。
テンプレートチャートを使用し、ロボットの稼働状況を折れ線グラフで表示します。
テンプレートチャートを使用する場合、先に情報を表示するコンポーネントを選択する必要があります。
3Dワールドで、ロボットを選択し、[統計情報]ウィンドウで、[テンプレートチャート]の[使用状況]をクリックします。
[使用状況]は、選択したコンポーネントの状態が、Busy、またはSetupの場合、値を100にし、それ以外の場合、値を0にすることで、稼働状況を表示できます。
[使用状況]ウィンドウの[データの期間]では、統計情報をグラフに反映する間隔を設定できます。
[前回のインターバル]の場合、[統計情報]グループの[間隔]で設定した間隔ごとに、表示する情報を更新できます。
[シミュレーション作動]の場合、表示される統計情報は、1回のシミュレーションの累計です。
[前回のインターバル]を選択し、ロボットの状態がBusy、またはSetupになる時間を確認します。
[使用状況]ウィンドウの[閉じる]をクリックします。
ロボットの待機状態と稼働状態の割合を折れ線グラフで比較します。
[統計情報]ウィンドウで、[シンプルチャート]の[ラインチャート]を選択します。
グラフのタイトルを設定するため、[プロパティ]ウィンドウで、[グラフ3]の[名称]に[RV-7FRL- 状態の割合比較]と入力します。
[タイトルの可視性]にチェックを付けることで、グラフにタイトルを表示できます。
待機状態の割合を表示するため、[データ系列]の[名称]にIdleと入力します。
[コンポーネント]と[プロパティ]で表示する情報を設定できます。
[コンポーネント]をクリックし、表示される[＋]アイコンをクリックします。
[Add コンポーネント items]ウィンドウで[RV-7FRL]を選択します。
[Add コンポーネント items]ウィンドウを閉じます。
[プロパティ]ウィンドウの[プロパティ]でStatistics.IdlePercentageを選択します。
[系列の追加]をクリックすることで、表示する情報を追加できます。
稼働状態の割合を表示するため、[名称]にBusyと入力します。
[コンポーネント]で[RV-7FRL]、[プロパティ]で[Statistics.BusyPercentage]を選択します。
グラフに情報の名称を表示するため、[説明文の可視性]にチェックを付けます。
グラフに、黄色の線がIdle、緑の線がBusyと表示されたことがわかります。
シミュレーションを実行します。
[RV-7FRL - 使用状況]では、ロボットの稼働状況を表示しています。
ロボットが稼働状態の時、値は100、待機状態の時、値は0です。
[RV-7FRL - 状態の割合比較]では、ロボットの待機状態と稼働状態の割合を比較しています。
4つ目のワークをセンサーが検知し、シミュレーションが停止したことがわかります。
シミュレーションをリセットします。
ロボットの稼働状況をグラフで表示する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットの動作経路の計画と追跡をしてみよう

ロボットの動作経路を計画する方法と、その経路を追跡する方法
https://youtu.be/ZGMyZ9s4n7s

ツールセンターポイントを使用しある位置から別の位置へのロボットの動作を追跡する方法を説明します。
4台のロボットを配置します。
[プログラム]タブに移動します。
シグナル17から32を使用しロボットの動作を追跡します。
Generic Scara Robotを選択し[プログラムエディタ]には設定済みのステートメントが表示されており、ロボットがP1に移動しシグナル19をTRUEで出力することで、ロボットの動作を追跡します。
動作を確認します。
Generic Scara Robotを選択し、[コンポーネントプロパティ]に移動します。
アクション設定の下にはシグナルアクションがあり、出力に19を設定します。
出力19にはロボットの「ツールフレーム3」とマテリアルの「green」が設定されています。
シミュレーションを再生し動作を確認します。
ロボットがP1からP4まで動作し、緑色で動作を追跡しました。
シミュレーションをリセットします。
別の方法でロボットのある位置から別の位置への線を表示する場合、[表示]グループの[ラインコネクト]にチェックをつけます。
ロボットを選択することで、ロボットが動作する順番に位置と位置を線でつないでいることが確認できます。
他のロボットの動作を確認します。
Generic Scara Robotの選択を解除しシミュレーションを再生します。
Generic Articulated Robotは弧を描くように上下に動作し、緑色で動作を追跡しています。
Generic Scara Robotと同じ出力シグナルを使用しているか確認します。
Generic Articulated Robotを選択し動作を確認します。
[プログラムエディタ]では出力シグナル19を使用しています。
次のロボットの動作は追跡することで長方形を描いています。
最後のロボットは接続されたツールを使用しており、追跡する位置はツールの先端に設定されています。
シミュレーションを一時停止し最後のロボットを選択します。
ロボットは出力シグナル17を使用しており、ツールフレームはツールのツールフレームをインポートし設定しています。
ツールをロボットから取り外した場合、ツールの位置を表示することができます。
ツールフレーム1を確認します。
ツールフレーム1を設定し、座標をオブジェクト座標に切り替えます。
シミュレーションを再生することでツールフレームの動作を表示することができます。
3Dワールドツールバーのフレームタイプをクリックし、ロボットツールにチェックをつけます。
インポートされたツールフレームTCPとツールフレーム位置が表示されました。
ロボットで溶接作業をする場合の設定方法を説明します。
最初にeカタログに移動し[公開のモデル]-[レイアウト]と展開します。
Geminiに登録されているレイアウトを配置することができます。
Layoutsをクリックし「Robotic Welding  Cell (no program)」を3Dワールドにドラッグまたはダブルクリックすることでレイアウトを配置することができます。
ロボットにツールが接続されており、ロボットがワークポジショナー上にあるワークを溶接します。
ロボットにワークを溶接する指示を出します。
ロボットの動作を追跡するため、ロボットのツールフレームをツールの先端に移動する必要があります。
[プログラム]タブに移動します。
[ジョグ]を使用しロボットを選択します。
ツールの先端にTCPというツールフレームがあります。
ツールフレーム1をTCPと同じ位置に移動します。
[ジョグ]ウィンドウに移動し[ツール]にツールフレーム1を設定後、歯車アイコンをクリックします。
必要に応じ、ドロップダウンメニューを変更することで、別のツールフレームまたはベースフレームを編集することができます。
[ツール]グループの中にある[スナップ]をクリックし、ツールフレーム1をTCPの位置に移動します。
[ツール]スナップのスナップタイプをフレームに変更します。
3DワールドでTCPをクリックし移動します。
座標をオブジェクト座標に変更することで、Z軸が下を指すことを確認します。
インポートしたツールフレームを使用しロボットに移動する指示を出します。
[ジョグ]ウィンドウに戻りベースにベースフレーム1を設定し、ツールにインポートされたツールフレームTCPを設定します。
3Dワールドのロボットにエッジを溶接する指示を出します。
ワークポジショナーを拡大後ヘッドライトをオンにすることで、カメラの方向から光を照射しワークのエッジを見やすくすることができます。
[ツール]グループに戻り[スナップ]をクリックします。
ツールのみ移動させているように見えますが、ロボット全体を移動させています。
ロボットを移動させる位置を3Dワールドでクリックするためワークの角をクリックします。
ツールとロボットが移動しました。
ツールがエッジに干渉しているためY軸を中心に回転させます。
[プログラムエディタ]のメインルーチンに直線補間ステートメントを追加します。
矢印をドラッグしロボットを移動させ、各軸補間ステートメントを追加します。
ロボットの動作を追跡する設定をします。
セットバイナリ出力ステートメントを追加し、[ステートメントプロパティ]に移動後、ロボットのツールフレーム1を使用し、動作を追跡するためバイナリ出力ステートメントに17と入力します。
出力値にチェックをつけることでシグナル17の値をTRUEの状態で出力し動作の追跡をオンにします。
出力値のチェックを外すことでシグナル17の値をFalseの状態で出力し、動作の追跡をオフにすることができます。
[出力値]にチェックをつけます。
ロボットに別の位置まで溶接する指示を出すため、スナップをクリックします。
ワークのエッジをクリックしロボットを移動させます。
矢印をドラッグしロボットを回転させます。
メインルーチンに直線補間ステートメントを追加します。
ロボットはP2、P1と移動後動作の追跡をONにし、P2からP3への移動を追跡していますが、P3に移動後エッジから離れる位置が必要です。
[ジョグ]ウィンドウに移動しロボットを移動させ、直線補間ステートメントを追加します。
P2、P1、P3、P4の順番で移動します。
P3からP4に移動するとき、追跡をオフにします。
P3の下に追加するためP3を選択し、セットバイナリ出力ステートメントをクリックします。
ステートメントプロパティに戻り、バイナリ出力ステートメントに17と入力し、出力値はFalseであるためチェックはつけません。
シミュレーションをリセットし動作を確認します。
シミュレーションを再生します。
P1からP3への移動を赤色で追跡しました。
ツールの先端位置で追跡をしない場合、オフセットを設定する必要があります。
コンポーネントプロパティで設定するため、3Dワールドでロボットを選択します。
レイアウトやコンポーネントを構築するときは、[ホーム]タブに戻る必要があります。
[コンポーネントプロパティ]には[シグナルアクション]というタブがあるためクリックします。
オプションの中にある[トレース幅]と[トレースZオフセット]を変更することで、動作の追跡のオフセットを設定することができます。
[トレースZオフセット]を10に設定します。
シミュレーションをリセットします。
P点位置を追跡するのではなくオフセットした位置を追跡します。
シミュレーションを再生します。
ロボットが移動しました。
エッジを拡大し確認すると、エッジと追跡した線の間には距離があり、オフセットを設定することができました。
追跡をONの設定がロボットプログラムで設定されていない場合、[プログラム]タブの[表示]グループの中にある[トレース]のチェックを外すことで、追跡を3Dワールドでは表示しません。
チェックボックスにチェックをつけることで、再度表示することができます。
動作を追跡するときロボットのデフォルトのツールフレームを使用しない場合、独自のツールフレームを設定する方法があります。
シミュレーションをリセット後3Dワールドでロボットを選択し、[コンポーネントプロパティ]に移動します。
アクション設定を展開し出力で17を選択します。
ロボットのシグナル17から32は、動作を追跡するアクションが事前定義されています。
シグナル17がTrueである場合追跡をオンにし、Fakseの場合追跡をオフにします。
使用ツールにはツールフレーム1が設定されていますが、ツールからインポートしたTCPに変更します。
ツールからインポートしたツールフレームを使用する場合、ツールをロボットから切断することで、設定からインポートしたツールフレームは外されます。
追跡するときの線の色を変更することもできます。
[マテリアル]で「salmon」を選択します 。
追跡をオフにするとき使用するツールフレームにもTCPを設定します。
シミュレーションをリセットします。
動作を確認します 。
ロボットの動作をピンク色の線で追跡しました。
ロボットの動作を追跡する方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

ロボットの外部TCPを使ってみよう

ロボットのアームに付けた外部ツールの中心点を使用して、ティーチングする方法
https://youtu.be/Euuisp3ufOw
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_037.zip

外部TCPを使用してロボットをティーチングする方法を説明します。
ファイルの開くから「External TCP Tutorial (start).vcmx」を開きます。
3Dワールドにツールが取り付けられたロボット部品が置かれたテーブルおよび外部ツールが表示されます。
ベースフレームはロボットの位置を簡易化するために使用されるロボット座標系です。
オブジェクトの位置や方向を定義するためのローカルの座標系として使用できます。
3Dワールドのツールバーからフレームタイプを選択しロボットベースにチェックを入れベースフレームを可視化します。
[プログラム]タブから[ジョグ]をクリックしロボットを選択します。
[ジョグ]パネルのベースをBASE_1に設定し歯車マークをクリックします。
マニピュレーションが[ジョグ]から[移動]に変わりロボットのBASE_1の位置にマニピュレーターが表示されます。
[ベースプロパティ]パネルからノードをテーブルテーブルに設定するとBASE_1がテーブルに接続されます。
ベース1はロボットのワールドフレームに あるためテーブルの原点に移動します。
[ツール]グループから[スナップ]を選択します。
ベーススナップパネルのスナップタイプを原点に設定します。
3Dワールドでテーブルにカーソルを合わせると黄色い直方体が表示されます。
その状態でクリックするとBASE_1を移動することができます。
[ベースプロパティ]パネルの左上にあるドロップダウンメニューからBASE_2を選択します。
BASE_2はロボットのワールドフレームにあるためパートの原点に移動します。
[ツール]グループから[スナップ]を選択します。
ベーススナップパネルのスナップタイプを原点に設定します。
3Dワールドでパートにカーソルを合わせるとエッジが黄色で表示されます。
その状態でクリックするとベース2を移動することができます。
[ベースプロパティ]パネルからノードをカートパートに設定します。
BASE_2がパートに接続されパートの原点に配置されます。
ツールをロボットに取り付けるとインポートされたツールフレームがロボットで使用可能になります。
[ジョグ]パネルのツールのドロップダウンメニューの中にインポートされたツールフレームが表示されます。
3Dワールドのツールバーからフレームタイプを選択しロボットツールにチェックを入れツールフレームを可視化します。
テーブル上のパーツをピックアップするため、ロボットはインポートされたツールフレームである、gripperTCPを使用します。
ロボットのTOOL[1]は出力信号1にマッピングされており、把持及び開放アクションに使用できます。
[プログラム]タブから[ジョグ]をクリックします。
ロボットアームセンターにマニピュレーターが表示されます。
[ジョグ]パネルからツールをTOOL[1]に設定し歯車マークをクリックします。
TOOL[1]をgripperTCPと同じ位置と向きに移動します。
[ツール]グループから[スナップ]を選択します。
[ツールスナップ]のスナップタイプをフレームに設定します。
gripperTCPをクリックしTOOL[1]を移動します。
ツールフレームはロボットの位置決めに使用されるツールセンターポイントTCPです。
TCPが移動する位置にロボットアームが追従します。
テーブルからパーツをピックアップした後ロボットは外部ツールの先端の周りでパーツを動かします。
ツールではなくロボットを動かすためにはロボットのTOOL[2]を外部ツールに接続し外部TCPとして使用します。
[ツールプロパティ]パネルの左上にあるドロップダウンメニューからTOOL[2]を選択します。
[ツールプロパティ]パネルからノードをフィーダーフィーダーに設定します。
TOOL[2]がフィーダーに接続されフィーダーの原点に配置されます。
TOOL[2]を外部ツールの先端の面の中心に移動します。
[ツール]グループから[スナップ]を選択します。
[ツールスナップ]のスナップタイプを面に設定します。
外部ツールの先端の面の中心をクリックしTOOL[2]を移動します 。
[プログラム]タブの[マニピュレーション]グループから[ジョグ]を選択します。
[ジョグ]パネルの座標をやベースをベース1ツールをgripperTCPに設定します。
ロボットをパーツの上面中心に移動します。
[ツール]グループから[スナップ]を選択します。
TCPスナップパネルのスナップタイプを[エッジと面]に設定します。
パーツの中心を クリックしロボットを移動します。
[プログラムエディタ]パネルから[シーケンスを追加]をクリックし新しいシーケンスを作成します。
[ルーチンプロパティ]から名前をPickに変更します。
Pickを選択した状態で直線補間ステートメントを追加しピックする位置を覚えさせます。
セットバイナリ出力ステートメントを追加します。
[ステートメントプロパティ]パネルのバイナリ出力ステートメントを1に設定し、出力値にチェックを入れ把持アクションを指示します。
ロボットをZ軸方向に動かし直線補間ステートメントを追加し交代位置を覚えさせます。
アプローチポジションとして、各軸補間ステートメントを追加しシーケンスの先頭にドラッグで移動します。
メインを選択しPickシーケンスを呼び出すコールシーケンスステートメントを追加します。
[ステートメントプロパティ]パネルのルーティンがPickに設定されていることを確認します。
シミュレーションを再生しロボットがパーツをピックアップすることを確認します。
シミュレーションをリセットします。
外部ツールの先端にパーツを配置するようにロボットをティーチングします。
停止するまでシミュレーションを再生します。
ロボットがプログラムを完了し部品をピックアップしている状態にします。
[プログラム]タブの[ツール]グループから[整列]をクリックします。
[整列]パネルの設定をポジションを設定およびプレビューのみチェックが入った状態にします。
スナップタイプは[エッジ]もしくは[エッジと面]に設定します。
パーツの上面の外部ツールに最も近い角のポイントをクリックします。
[整列]パネルの[スナップタイプ]をフレームに変更しTOOL[2]を選択します。
[プログラムエディタ]パネルでメインを選択しシーケンスの最後に直線補間ステートメントを追加します。
シミュレーションをリセットし再度再生します。
ロボットがパーツをピックアップし外部ツールに移動することを確認します。
シミュレーションをリセットします。
ツールパスを調整します。
停止するまでシミュレーションを再生します。
TOOL[2]を選択し[ツールプロパティ]パネルの[座標]を「オブジェクト」に切り替えます。
Z軸を中心にTOOL[2]を-90度回転させX軸をパーツのエッジに合わせます。
シミュレーションをリセットします。
停止するまでシミュレーションを再生します。
[ジョグ]パネルでオブジェクト座標系を使用しベースをパーツに取り付けられたベースフレームであるTOOL[2]に設定します。
ツールを外部ツールに取り付けられたツールフレームであるTOOL[2]に設定します。
外部TCPが自動的にTRUEに変更されることを確認します。
[プログラムエディタ]パネルから[シーケンスを追加]をクリックし新しいシーケンスを作成します。
名前を「Tooling」に変更します。
直線補間ステートメントを追加します。
モーションステートメントの補間がベースフレームからツールフレームに行われるため、ロボットの位置はTOOL[2]の向きを継承します。
ツールフレームからベースフレームへのモーションステートメントの補間を逆にすることもできます。
その場合ロボットの位置はベースフレームの向きを継承します。
[ステートメントプロパティ]パネルでExternalTCPにチェックを入れます。
モーションステートメントがベースにあることを確認します。
TCPの方向を参照しロボットの位置に適用する場合には実用的ではない可能性があります。
ロボットの位置をTOOL[2]の位置に戻すためExternalTCPのチェックを外します。
ジョグを使用してロボットをX軸方向に500mm移動します。
Z軸を中心にロボットを-90度回転させます。
[プログラムエディタ]パネルのToolingに直線補間ステートメントを追加します。
操作を繰り返しパーツの上面のエッジに沿って動作する直線補間ステートメントを3つ追加します。
シミュレーションをリセットします。
パーツにアタッチしたBASE_2が位置の親となりオブジェクトは親オブジェクトとともに移動します。
[プログラムエディタ]パネルからメインを選択しコールシーケンスステートメントを追加します。
[ステートメントプロパティ]パネルのルーティンをToolingに設定します。
シミュレーションを再生します。
ロボットがパーツを外部TCPに沿って移動させることを確認します。
シミュレーションをリセットします。
外部TCPを使用してロボットをティーチングする方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

ロボットの重力プロパティを理解しよう

ロボットが部品を離す際の重力方向の設定方法
https://youtu.be/TGwY6eJmC7Y
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_023.zip

ロボットでコンポーネントをリリースする場合の重力の方向プロパティについて説明します。
重力の方向はロボットがコンポーネントをリリースできる場所を論理的に判断するために使用する値です。
例えばコンベア上、パレット上、または箱の中などにリリースします。
機能を確認するため3Dワールドで任意のロボットを選択し[コンポーネントプロパティ]に移動します。
[アクション設定]を展開します。
ロボットには出力1から16にコンポーネントの把持、開放するアクションが事前定義されています。
ロボットで把持、解放を行います。
出力の値がTRUEである場合コンポーネントをつかみ、FALSEである場合コンポーネントをリリースします。
つかむにはコンポーネントを検出する範囲と範囲の中心を定義するツールフレームを設定します。
ロボットが掴むことができるコンポーネントを検出するため範囲設定を行います。
ロボットが掴んでいるコンポーネントをリリースする場合重力の方向を使用します。
重力とは3Dワールドの-Z軸方向に働く力です。
3Dワールド左上にある不動原点で軸方向を確認することができます。
重力の方向に-Z軸方向の距離を定義します。
初期状態では25mmに設定されています。
ロボットがコンポーネントをつかんでいる場合25mm以内にリリースできるコンポーネントが存在していることを確認し、検出されたコンポーネントに対して掴んでいるコンポーネントをリリースします。
機能を確認するため3Dワールドにレイアウトを構築します。
レイアウトの構築後[プログラム]タブに移動します。
ロボットに設定済みのプログラムがあることを確認します。
コンポーネントをピックアンドプレイスするためのプログラムです。
シミュレーションを再生します。
一方のコンベアからはパレットが流れもう一方のコンベアからは円柱が流れました。
ロボットは円柱をピックアンドプレースしましたがパレットではなくコンベアにリリースしました。
ロボットが円柱を配置するサブルーチンを確認します。
P6のポイントを選択してコンベアに接近させ次のP4のポイントでコンポーネントを配置する位置に移動します。
出力1をFalse値の状態で送信しコンポーネントをリリースします。
SetOut 1の上に停止ステートメントを追加します。
シミュレーションをリセットし再度再生します。
停止ステートメントはロボットプログラムを確認する場合に役立ちます。
停止ステートメントを実行することでシミュレーションを自動的に停止させます。
ロボットは掴んでいるコンポーネントを重力の方向25mm以内にあるコンポーネントにリリースします。
[ジョグ]パネルに移動し座標Zに「-25」と追記します。
円柱を選択することで円柱とパレットおよびコンベアが衝突していることが確認できます。
円柱の底面がコンベアに接触しているため円柱をコンベアにリリースしています。
シミュレーションを再生します。
コンベア上で円柱とパレットが別々に移動していますが一緒に移動する必要があります。
[ホーム]タブに移動し円柱の接続先を確認します。
[PnP]を使用して確認すると円柱はコンベアに接続されておりパレットもコンベアに接続されています。
一緒に移動させるため円柱とパレットを接続します。
修正をするためロボットを選択し、[コンポーネントプロパティ]に戻り、[シグナルアクション]の出力1に移動し、重力の方向を「25mm」から「1mm」に変更します。
シミュレーションを再生し動作を確認します。
円柱をパレットの表面に配置します。
シミュレーションの再生を続け、円柱とパレットを流します。
円柱を選択しコンベアではなくパレットと接続していることを確認します。
重力の方向を「1mm」に設定することでパレットを検出し円柱をパレットにリリースすることができます。
重力の方向に別の値を入力します。
ロボットを選択し[シグナルアクション]の出力1に戻ります。
パレットの厚さを確認するためフィーダーを選択します。
[ProductParams]タブに移動し高さが「10mm」であることを確認します。
ロボットの[シグナルアクション]に戻り 重力の方向を「11」に変更することでパレットの代わりにコンベアを検出し 円柱をコンベアにリリースできます。
シミュレーションを再生します。
停止ステートメントでシミュレーションが停止するため再度再生します。
円柱を選択しコンベアに接続されていることを確認します。
パレットを検出し円柱をリリースするためには重力の方向を1から10mmの範囲に設定する必要があります。
シグナルアクションに戻り重力の方向を10に変更します。
シミュレーションを再生します。
円柱はパレットにリリースされました。
ワークの積み重ね等で最下層のワークに対してリリースしたい場合は必要に応じて重力の方向を調整します。
出力1を使用してワークを配置し別の出力を使用して別のワークを配置することもできます。
出力シグナルごとに異なるアクション、異なる重力の方向を設定することができます。
ロボットでコンポーネントをリリースする場合の重力の方向プロパティについての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

ロボットの衝突を検知してみよう

ロボットと周辺機器の干渉を検出する方法
https://youtu.be/_7p0nUd4C6I
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_019.zip

3Dワールドでロボットをプログラミングする場合の干渉を検出する方法を説明します。
ロボットにピックアンドプレイスを指示する場合ロボットと他のオブジェクトとの干渉検出について説明します。
eカタログの[タイプ別モデル]にある[Component Template]をクリックし「Feeder Template」と「Conveyor Template」を配置します。
[タイプ別モデル]にある[Robots]を展開します。
[Visual Components]をクリックしGenericArticulatedRobotを配置します。
ロボットをフィーダーとコンベアに近づけます。
ロボットの先端にグリッパを取り付けます。
タイプ別モデルにあるRobot Toolsを展開します。
Visual Componentsをクリックし「Parametric Suction Cup Gripper」を追加します。
グリッパをロボットの先端に接続します。
レイアウトの作成については以上となります。
ロボットのティーチングを行います。
[プログラム]タブに移動します。
ジョグを使用し3Dワールドでロボットを選択します。
[ジョグ]ウィンドウに移動しツールにロボットがグリッパからインポートしたツールフレームであるGripperTCPを設定します。
3Dワールドでロボットを移動しコンベアと衝突させます。
ロボットはコンベア内にありますが 干渉が発生したという視覚的なフィードバックは得られません。
3Dワールドで干渉モードをオンにする場合、[干渉検出]グループに移動し[ディテクタを有効にする]のチェックボックスにチェックを入れます。
ディテクタを有効にすることでレイアウト内のすべての干渉ディテクターがオンになります。
干渉ディテクタを確認する場合[ディテクタを編集]をクリックし[干渉ディテクタ]ウィンドウで編集します。
初期状態ではすべてのレイアウトに「選択対ワールド」という干渉ディテクタがあります。
初期状態ではオンになっていますが必要に応じオフにすることができます。
「選択対ワールド」は選択しているコンポーネントと他のすべてのコンポーネントを比較することができます。
選択したコンポーネントと他のコンポーネントが干渉した場合3Dワールドにフィードバックします。
ロボットを選択し再度衝突させます。
ロボットのグリッパがコンベアと干渉したことを視覚的に確認できます。
グリッパはロボットにアタッチされたコンポーネントであるためグリッパとともにロボットもハイライトします。
グリッパを選択した場合ロボットがコンベアと干渉していますがハイライトしません。
干渉ディテクタは選択したコンポーネントと他のすべてのコンポーネントを比較するように設定されています。
グリッパのみを他のコンポーネントと比較しています。
グリッパを移動しコンベアと衝突させるとフィードバックが得られます。
「選択対ワールド」についての説明は以上となります。
[干渉ディテクタ]ウィンドウに戻りプロパティを確認します。
[干渉を検出]は検出した干渉を全て表示する設定と最初に検出した干渉のみ表示する設定を切り替えることができます。
[干渉を検出]を最初に設定しロボットを選択します。
コンベアと干渉させたときコンベアとグリッパがハイライトします。
ロボットを移動させコンベアと干渉させていますがロボットはハイライトしません。
選択したコンポーネントとコンベアの間に最初に発生した干渉はグリッパとコンベア間の干渉となります。
以上が検出した干渉を全て表示する設定との違いです。
ロボットを移動しコンベアから離し[干渉ディテクタ]ウィンドウに戻り[干渉を検出]を「全て」に戻します。
グリッパがコンベアと干渉するとハイライトするため発生したすべての干渉を表示していることが確認できます。
[干渉を検出]で「最初」を選択します。
最初にロボットがコンベアと干渉し、続けてグリッパも干渉しますが最初に干渉したロボットのみハイライトします。
コンベアについても同様です。
次に干渉耐性について説明します。
干渉が発生する前に検出する場合ロボットがコンベアと干渉した時にロボットを停止させる、もしくは干渉耐性に基づいて干渉を検出しロボットとコンベアが接触する前に干渉が発生する可能性のあるコンポーネントをハイライトさせることができます。
[干渉ディテクタ]ウィンドウに戻りプロパティを確認します。
[干渉耐性]と[最短距離を表示]といった2つのプロパティがあります。
[最短距離を表示]にチェックを入れ[干渉耐性]を「50mm」に設定します。
グリッパとコンベアが50mm以内に近づいた場合3Dワールドでハイライトされグリッパとコンベア間の最短距離を表示します。
グリッパを近づけ続けるとグリッパは干渉を検出し続け最短距離は更新されます。
コンベアとロボットが50mm以内に近づいた場合ロボットをハイライトし最短距離を表示することが確認できます。
最短距離を変更する場合[干渉ディテクタ]ウィンドウに戻り[干渉耐性]を「100」に設定します。
3Dワールドに戻りコンベアとロボットが100mm以内にあるため最短距離を表示します。
ロボットを移動し100mmより遠い場合ハイライトしません。
シミュレーション再生中ロボットが移動しコンポーネントと干渉する場合の動作を確認します。
シミュレーションをリセットしツールをGripperTCPに再度設定します。
ロボットをコンベアと干渉する位置に移動します。
[プログラムエディタ]のMainルーチンに各軸補間ステートメントを追加します。
リセット後シミュレーションを減速し再生します。
ロボットが移動しコンベアとロボットがハイライトしますがシミュレーションは停止しません。
衝突が発生した場合シミュレーションを停止させるための設定をします。
シミュレーションをリセットし[干渉検出]グループの[干渉の停止]にチェックをつけます。
シミュレーションを再生し動作を確認します。
ロボットとコンベアの干渉が検出され[干渉耐性]を使用しているためロボットとコンベアが接触する前にシミュレーションが停止しました。
衝突の可能性が検出され最短距離が表示されます。
シミュレーションをリセットし[干渉耐性]をオフにします。
[干渉ディテクタ]ウィンドウに戻り[干渉耐性]に0を入力し[最短距離を表示]のチェックを外します。
シミュレーションを再生し動作を確認します。
グリッパーとコンベアに干渉が発生したためシミュレーションが停止しました。
以上が停止設定を干渉発生前後で変更した違いです。
オリジナルの干渉ディテクタを作成します。
シミュレーションをリセットし[干渉ディテクタ]ウィンドウに戻ります。
「選択対ワールド」をオフにしオリジナルの干渉ディテクタを作成します。
+ボタンをクリックし[干渉ディテクタを追加]を選択します。
「干渉ディテクター#1」が追加されました。
AリストにあるコンポーネントとBリストにあるコンポーネントを比較します。
Aリストにコンポーネントを追加します。
3Dワールドでロボットを選択すると表示される[Aリストに追加]を選択します。
ロボットは緑色にハイライトされ[干渉ディテクタ]ウィンドウのAリストにロボットと構成するすべてのノードが追加されました。
ノードにカーソルを合わせると3Dワールドではノードを赤い枠が囲んでいることが確認できます。
現状グリッパは干渉ディテクタに含まれていません。
グリッパを選択し[干渉ディテクタ]ウィンドウの[選択を追加]をクリックしAリストに追加します。
ロボットおよびグリッパと比較するコンポーネントをリストBに追加します。
コンベアをBリストに追加します。
3Dワールドでコンベアを選択し[Bリストに追加]を選択します。
コンベアは青色にハイライトされ[干渉ディテクタ]ウィンドウのBリストに追加されます。
シミュレーションを再生し動作を確認します。
AリストのコンポーネントとBリストのコンポーネント間の干渉が検出されます。
干渉ディテクタからグリッパを除外し動作を確認します。
[干渉ディテクタ]ウィンドウのAリストに戻りParametric Suction Cup Gripperのチェックを外しシミュレーションを再生します。
グリッパではなくロボットのmountplateとコンベア間の干渉が検出されます。
シミュレーションをリセットしGripperLink、mountplate、Axis6のチェックを外します。
シミュレーションを再生します。
ロボットのAxis5とコンベア間の干渉が検出されます。
Axis5、Axis4のチェックを外し シミュレーションを再生します。
干渉は検出されません。
Axis4に再度チェックを入れ干渉ディテクター#1がオンになって いることを確認し、[干渉ディテクタ]ウィンドウを閉じます。
シミュレーションを再生します。
ロボットのAxis4とコンベア間で発生している干渉が検出されます。
シミュレーションをリセット後コンベアを選択した状態で[干渉ディテクタ]ウィンドウに戻り干渉ディテクター#1をオフにします。
+ボタンをクリックし[干渉ディテクタを追加]を選択します。
3Dワールドでコンポーネントを選択後、干渉ディテクタを追加することでコンポーネントがリストに自動的に設定されます。
3Dワールドでコンベアを選択後干渉ディテクタを追加したためコンベアはAリストに追加されコンベア以外のコンポーネントはBリストに追加されます。
Bリストからフィーダーを除外または削除しロボットおよびグリッパをコンベアと比較します。
シミュレーションを再生しグリッパおよびロボットとコンベア間での干渉が検出されます。
[干渉ディテクタ]ウィンドウに戻り干渉ディテクター#2の名前を変更します。
プロパティの名称をコンベヤーvsロボット+グリッパーに変更し[干渉ディテクタ]ウィンドウを閉じます。
再度ウィンドウを開き名前が更新されたことを確認します。
干渉ディテクタをレイアウトとともに保存します。
[干渉ディテクタ]ウィンドウを閉じます。
レイアウトを保存するためファイルタブを選択し名前を付けて保存をクリックします。
保存する場所にMyモデルズを指定し保存します。
3Dワールドのレイアウトを全て削除するため[ホーム]タブに移動しコントロールキーとNキーを押します。
eカタログのマイモデルをクリックし保存したレイアウトを確認します。
3Dワールドにドラッグアンドドロップし配置します。
シミュレーションを再生し動作を確認します。
ロボットが移動しコンベアとロボット間に発生した干渉が検出されシミュレーションが停止しました。
干渉ディテクタがレイアウトとともに保存されたことが確認できます。
[プログラム]タブに戻り[干渉ディテクタ]ウィンドウを開き追加した干渉ディテクタを確認します。
ディテクタを無効にしレイアウトを削除後再度レイアウトを呼び出し干渉ディテクタを確認します。
[干渉検出]グループのディテクターを有効のチェックを外しレイアウトを削除します。
[ホーム]タブに戻り保存したレイアウトをドラッグアンドドロップで配置し[プログラム]タブに戻ります。
干渉ディテクタは存在しオンになっていますが3Dワールドで有効ではありません。
シミュレーションを再生し動作を確認します。
ロボットとコンベアが衝突しましたが干渉は検出されません。
3Dワールドでロボットをプログラミングする場合の干渉を検出する方法の説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

ロボットの設定をしてみよう

ロボットの動作のティーチングを行う方法
https://youtu.be/_5SzNmTbH5g
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_016.zip

ロボットの概要について説明します。
最初に、ロボットのユーザーインターフェースについて説明します。
ユーザーインターフェースには、各軸補間ステートメントと直線補間ステートメントがあります。
各軸補間ステートメントは、指定位置に到達できるようにジョイント値を補間するステートメントです。
目標位置へ移動する速度と加速度を、[ステートメントプロパティ]で変更することができます。
各軸補間ステートメントは、ジョイントが最小の動作を行うので、ジョグパネルのジョイントを見ると、「J1」から「J6」が最小の動作を行い、3Dワールドでは、フレーム「TCPFrame」が円弧を描きます。
直線補間ステートメントは、指定位置までの最短距離で到達できるジョイント値を補間するステートメントです。
直線補間ステートメントでは、位置、速度、および加速度を、[ステートメントプロパティ]で変更することができます。
目標位置へは最短距離で到達するので、ジョグパネルのジョイントを見ると、各軸補間ステートメントと比較して、ジョイントの作業量が多く、3Dワールドでは、フレーム「TCPFrame」が直線を描きます。
各軸補間と直線補間の違いの1つとして、各軸補間では、その位置におけるロボットの設定を変更できることに対し、直線補間では、ロボットの設定が保持されることが挙げられます。
設定済みの各軸補間ステートメントを選択します。
ステートメントプロパティの「コンフィグ」を、「FRONT ABOVE NOFLIP」から「FRONT ABOVE FLIPPED」に、変更することで、ジョイントを反転させることができます。
コンフィグは、ロボットの種類により、名称が異なります。
ユーザーインターフェースについての説明は以上となります。
次に、ロボットのベースフレームとツールフレームの概要について説明します。
ツールフレームは、接続されている、別コンポーネントのフレームを使用するための、参照点です。
ロボットは、ロボットに接続されている、溶接ガンのフレーム「TCPFrame」を参照しています。
ベースフレームは、コンポーネントの位置を単純化するために使用する、スペースの定点です。
Geminiでは、ジョグ パネルの「ベース」と「ツール」で、使用するベースフレームとツールフレームを、設定することができ、フレームの横にある歯車のアイコンをクリックすると、フレームを編集することができます。
ロボットには、ベースフレームとツールフレームが16個ずつ、設定されていますが、ロボットに接続されたコンポーネントから、フレームをインポートすることもできます。
ロボットのベースフレームとツールフレームの概要についての説明は以上となります。
次に、ツールフレームの詳細について説明します。
使用するツールフレームは1つですが、複数のツールフレームが必要な場合もあります。
ツールフレーム「TOOL0」は溶接ガンの先端に、「TOOL1」は溶接ガンの中間位置に設定します。
溶接ガンで、ワークを溶接するステートメントには「TOOL0」を使用し、ツールスタンドの位置を指定するステートメントでは、「TOOL1」を使用します。
ツールフレームについての説明は以上となります。
次に、ベースフレームの詳細について説明します。
コンポーネントを移動するとき、目標位置も一緒に移動させたい場合、ベースフレームを、移動させるコンポーネントにアタッチすると、コンポーネントの移動に、目標位置が追従します。
ジョグパネルのベースで「UFRAME0」を選択し、各軸補間ステートメントで、目標位置を指定します。
ジョグパネルに戻り、ベースの横にある歯車アイコンをクリックします。
ベースプロパティのノードの横にあるアイコンをクリックし、3Dワールドから[Tool Changer Tool Stand]を選択することで、ベースフレームを、[Tool Changer Tool Stand]にアタッチすることができます。
[Tool Changer Tool Stand]を選択し、移動すると、目標位置が追従します。
「UFRAME1」を使用し、目標位置を指定、ワークにアタッチすることで、[Tool Changer Tool Stand]に追従する目標位置と、ワークに追従する目標位置を分けることも可能です。
ベースフレームを使用し、プログラムを再利用し、パターンを作成することもできます。
サブルーチン「Weld2」は、ワークの最初のエッジを溶接するサブルーチンです。
ワークの別のエッジを溶接するために、プログラムを再利用します。
シミュレーション実行中に、ベースフレームの位置を変更することで、「Weld2」を再利用することができます。
ワークのエッジとエッジの間を測定し、その距離だけベースフレームを相対的に移動させます。
シミュレーション実行中にベースフレームの設定を変更するので、「Main」に、「ベース定義ステートメント」を追加し、「ベース定義ステートメント」のベースで「UFRAME0」を選択し、「IsRelative」にチェックをつけ、浮動原点を確認しながら、先程の測定結果を入力します。
「Main」に「Home」を呼び出す「コールシーケンスステートメント」を追加し、シミュレーションを実行すると、ワークの最初のエッジを溶接し、ベースフレームの位置を変更し、別のエッジを溶接しています。
ツールフレームとベースフレームについての説明は以上となります。
次に、ジョグパネルについて説明します。
多関節ロボットには、ジョグパネルから選択できる、構成が8つあります。
ジョグパネルの「コンフィグ」を変更すると、ツールフレームの位置は変化しませんが、ロボットの姿勢が変化します。
シミュレーションを実行すると、ロボットがワークを持ち上げ、所定の位置にワークを置くために、ロボットは根元部分から回転し、枠に衝突する危険があります。
ロボットの回転を減らしたい場合、各軸補間ステートメントごとに、使用するロボットの構成を変更することができるので、設定済みの各軸補間ステートメントを選択し、ジョグパネルの「コンフィグ」を、「cfx4」に変更します。
変更した「コンフィグ」を、各軸補間ステートメントに反映させるために、プログラムエディタの「タッチアップ」をクリックします。
直線補間ステートメントは、すぐ上にある各軸補間ステートメントのコンフィグを、継承しています。
シミュレーションを実行すると、根元部分のジョイントを使用していないことが分かります。
しかし、他のジョイントがすべての作業を行っています。
ジョグパネルの説明は以上となります。
次に、ロボット動作の最適化について説明します。
ジョイントの回転は、ロボットの多関節運動に関連しています。
ロボットがワークを持ち上げ、所定位置にワークを置くとき、ワークを回転させていますが、この回転は不要な動作なので、ジョイント値を変更します。
ワークを置く直前の、各軸補間ステートメントを選択し、ジョグパネルを開き、ジョイントを変更します。
1番下のジョイント値がマイナス361の状態だと、回転してしまうので、ジョイント値を変更します。
タッチアップ機能を使用し、各軸補間ステートメントの設定を、更新し、シミュレーションを実行すると、ロボットはワークを回転させることなく、所定の位置にワークを置きます。
ロボット動作の最適化についての説明は以上となります。
ロボットの概要についての説明は以上となります。

=================================================================================

ロボットの設定項目について知ろう

ロボットのコンポーネントプロパティを設定する方法
（関連動画：ロボットの設定方法の基礎を学ぼう、ロボットを制御するコントローラーについて知ろう(1/3)～(3/3)、アセンブリについて知ろう、アセンブリ機能を使ってみよう、組立や分解ができる製品を定義しよう、複数のパーツを使用して製品を組み立てよう、ロボットにツールを取り付けて設定してみよう、AGVを作ってみよう(2/12)、ロボットが届く範囲を確認しよう(2/5)）
https://youtu.be/Rl0mnpJ9NtE

ロボットのコンポーネントプロパティについて説明します。
ロボットの設定方法の動画として、ロボット単体を使用する場合は「ロボットの設定方法の基礎を学ぼう」、ラインシミュレーションの中でロボットを使用する場合は「ロボットを制御するコントローラーについて知ろう(1/3)～(3/3)」も参照してください。
本動画では、バージョン1.410以降のeカタログを使用しています。
[eカタログ]ウィンドウ、[タイプ別モデル]-[Conveyors]-[Visual Components]からRV-7FRLLを配置します。
ダブルクリックすることで、3Dワールドの原点に配置できます。
ドラッグ＆ドロップすることで、マウスボタンをはなした位置に配置できます。
ロボットを選択し、[コンポーネントプロパティ]ウィンドウを表示します。
[既定]タブのプロパティについて説明します。
[J1]から[J6]は、ロボットの可動部の現在値です。
ロボットの土台部分から順に、J1、J2となっています。
ロボットの種類によって可動部の数と、名前が異なる場合があります。
[RobotModelID]は、メーカー名と、ロボットの機種名です。
入力Boxが黒い場合、入力できません。
入力できない原因は、ユーザーによる編集ができない設定がされている、シミュレーションがリセットされていない、別のコンポーネントと接続されているなどが考えられます。
[RobotModelID]は、ユーザーによる編集ができない設定です。
プロパティの入力条件は、[モデリング]タブで変更することもできます。
[Executor]タブのプロパティについて説明します。
[ルーピング]は、ロボットプログラムを繰り返し実行するか設定できます。
チェックをつけた場合、シミュレーション中に、Mainルーチンを繰り返し実行できます。
チェックを外した場合、シミュレーション中に、Mainルーチンを実行する回数は、1回です。
[有効です]は、ロボットプログラムを実行するか設定できます。
チェックをつけた場合、Mainルーチンを実行します。
チェックを外した場合、Mainルーチンを実行しません。
「Robot Transport Controller」と接続、PythonScriptでロボットプログラムを呼び出す等、自動的に有効/無効が切り替わる場合もあります。
[シグナルアクション]タブは、ロボットに設定されているシグナルと紐づいた動作に関する設定項目です。
シグナルと紐づいた動作を、シグナルアクションと言います。
ロボットには、連続した番号のシグナルがあります。
入力シグナルの名前は、Inputs、出力シグナルの名前は、Outputsです。
番号は、0から4096まであり、Outputsの一部の番号には、シグナルアクションが設定されています。
シグナル番号と、紐づける動作を変更する場合、[アクション設定]を設定します。
出力シグナル1から16には、ロボットの検出範囲内のコンポーネントをつかむ動作が紐づいています。
シグナルがTrueの場合、コンポーネントをつかみ、Falseの場合、コンポーネントをはなします。
検出範囲は、ツールフレームというロボット先端の基準点が中心となります。
検出範囲を確認する場合、[シグナルアクション]タブの[検出容積を表示]にチェックを付けます。
[検出ジオメトリー]で、検出範囲の表示方法を変更できます。
「Box」の場合、半透明な直方体で、「Line」の場合、外枠を線で、検出範囲が表示されます。
[検出容積ツール]は、検出範囲の中心となる基準点、[検出容積サイズ]は、基準点からのXYZの距離です。
[アクション設定]の[使用ツール]と[ボリュームサイズの検出]と、一致させることで、ロボットの検出範囲を確認できます。
はなしたコンポーネントをコンベア等に格納する場合、格納場所が、検出範囲内にある必要があります。
はなす時の検出範囲は、つかんでいるコンポーネントのバウンディングボックスの底面からの距離を指定します。
検出範囲内に、つかんでいるコンポーネントの次の格納場所がない場合、3Dワールドに格納されます。
[シグナルアクション]タブの[リリースでワールド更新]は、コンポーネントをはなした時、3Dワールドを更新できます。
[メッセージ表示]は、シグナルアクションの実行指令があった場合、シグナルアクションが実行されたかを、[出力]ウィンドウに表示します。
[ワールドにリリース]にチェックを付けることで、検出範囲内に、コンベア等があった場合でも、コンポーネントを3Dワールドにはなします。
[物理にリリース]は、つかんだコンポーネントをはなす時、コンポーネントに物理演算を付与できます。
[Never]の場合、いかなる時も、物理演算を付与しません。
[If Target not Detected]は、コンベア等のコンポーネントを受け渡す場所がない場合、物理演算を付与します。
すでに物理演算が付与されたコンポーネントの場合、物理演算を削除することはありませんが、重力の影響を受けない状態になります。
重力以外の、外から加わる力の影響は受けます。
[Always]の場合、いかなる時も、物理演算を付与します。
[マルチグラスプ]は、検出範囲内の、すべてのコンポーネントをつかむことができます。
複数のコンポーネントをつかみ、はなす時、通常、コンベア等には、1つずつ格納されます。
同時に格納する場合、[リリースされたコンポーネントのバンドル]にチェックをつけます。
つかむコンポーネントにロックがかかっている場合、ロボットはコンポーネントを移動させることはできません。
[ロックされたコンポーネント検出]にチェックをつけることで、ロックがかかっているコンポーネントをつかむことができます。
つかむコンポーネントが非表示の場合も、同様に、移動させることができません。
非表示のコンポーネントをつかむ場合、[非表示のコンポーネント検出]にチェックを付けます。
[GraspIncludeEmptyAssemblies]は、コンポーネントに、アセンブリという階層構造が存在する場合、有効な機能です。
アセンブリについての詳細は、動画「アセンブリについて知ろう」、「アセンブリ機能を使ってみよう」、「組立や分解ができる製品を定義しよう」、「複数のパーツを使用して製品を組み立てよう」を参照してください。
[GraspIncludeEmptyAssemblies]が[No-Delete]の場合、ロボットが、最初に検出したコンポーネントと、その子階層のコンポーネントをつかみます。
検出したコンポーネントが、その階層の最後のコンポーネントである場合、コンポーネントをつかみ、空になった階層と、その子階層は削除されます。
[No-Leave]の場合、[No-Delete]と同様に、最初に検出したコンポーネントと、その子階層のコンポーネントをつかみます。
ただし、空になった階層と、その子階層を削除することはありません。
[Yes]の場合、最初に検出したコンポーネントが、階層構造の一部である場合、すべての階層のコンポーネントをつかみます。
[ExcludeReleasingTo]は、つかんでいるコンポーネントを格納する場所から除外するリストです。
リストに追加されたコンポーネントには格納せず、3Dワールドに格納するため、コンベア上を移動しません。
[ExcludeGrasping]は、ロボットが、つかむ対象から除外するリストです。
[アクション設定]の出力シグナル17~32には、ロボットが動作した痕跡を残す動作が紐づいています。
シグナルがTrueの間、指定したツールフレームの移動経路を表示できます。
出力シグナル49から64も同様です。
表示するのは、ロボットの土台部分にあるベースフレームの移動経路です。
[シグナルアクション]タブの[トレース幅]を設定することで、表示する移動経路の幅を変更できます。
[トレースZオフセット]は、フレームの位置からZ軸方向に、移動させた位置に移動経路を表示できます。
単位は、ミリメートルです。
[アクション設定]の出力シグナル33~48には、検出範囲内のロボットツールと接続する動作が紐づいています。
シグナルがTrueの場合、ロボットツールを接続し、Falseの場合、ロボットツールとの接続を解除します。
ロボット内のどの接続設定と、ロボットツールを接続するか指定する必要があります。
詳細は、動画「ロボットにツールを取り付けて設定してみよう」を参照してください。
出力シグナル81は、指定したコンポーネントの動作した痕跡を残す動作が紐づいています。
シグナルがTrueの間、指定したコンポーネントの移動経路を表示できます。
詳細は、動画「AGVを作ってみよう(2/12)」を参照してください。
[WorkSpace]タブのプロパティについて説明します。
[Profile]は、J1を固定した状態で、可動可能な範囲を可視化できます。
[Envelope]は、J1を含む可動可能な範囲を可視化できます。
詳細は、動画「ロボットが届く範囲を確認しよう(2/5)」を参照してください。
ロボットのコンポーネントプロパティについて説明しました。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットの設定方法の基礎を学ぼう

ロボットのティーチング等、基礎の設定方法
（関連動画：ロボットでピック&プレイスしてみよう、ロボットを置き換えてみよう、ロボットにツールを取り付けて設定してみよう）
https://youtu.be/7cNBu_p_cyI
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_151.zip

ロボットの設定方法の基礎を説明します。ロボットで箱をピックアップします。
[Introducution to Robot Teaching_before.vcmx]をダウンロードし、開きます。
箱の前にあるロボットをロボットA、奥にあるロボットをロボットBとします。
[プログラム]タブを開きます。
[マニピュレーション]-[ジョグ]を選択し、ロボットAを選択します。
[ジョグ]ウィンドウの[ジョイント]から各ジョイントの値を変更するとロボットAが任意の位置に移動します。
シミュレーションをリセットします。
ロボットAのアームの先端をドラッグして箱の上面に移動させます。
[プログラムエディタ]ウィンドウの[サブプログラム]-[直線補間ステートメント]を選択します。
[プログラムエディタ]ウィンドウに[LIN P1]が作成されます。
箱を持ち上げる前のロボットAの位置を設定します。
ロボットAのアームの先端を+Z軸方向に移動します。
[プログラムエディタ]-[サブプログラム]-[各軸補間ステートメント]を選択します。
[プログラムエディタ]ウィンドウにモーションプログラム[PTP P2]が作成されます。
[PTP P2]をドラッグして1番前に移動します。
箱を持ち上げた後、[PTP P2]と同じ位置に移動します。
[プログラムエディタ]ウィンドウの[サブプログラム]-[直線補間ステートメント]を選択します。
[プログラムエディタ]ウィンドウに[LIN P3]が作成されます。
[LIN P3]をドラッグして1番後ろに移動し、順番を[PTP P2]-[LIN P1]-[LIN P3]とします。
シミュレーションをリセットします。
シミュレーションを実行すると[初期位置]-[P2]-[P1]-[P3]の順に移動します。
箱を持ち上げるためのプログラムを追加します。
[プログラムエディタ]ウィンドウの[サブプログラム]-[セットバイナリ出力ステートメント]を選択します。
[プログラムエディタ]ウィンドウに[Set OUT]が作成されます。
[Set OUT]をドラッグして[LIN P1]の後に移動します。
箱を持ち上げるために、信号をtrueに変更します。
[ステートメントプロパティ]-[バイナリ出力ステートメント]を「1」に変更し、出力値にチェックを入れます。
シミュレーションリセットします。
シミュレーションを実行するとロボットAが箱を持ち上げます。
シミュレーションリセットボタンを押した時のロボットAの初期位置を変更する方法を2つ説明します。
1つ目の方法は、ロボットAを任意の位置に動かした後に、シミュレーション再生ボタンの左側にある歯車を選択し、状態の保存をクリックします。
任意に移動したロボットAの位置が初期位置に設定されます。
2つ目の方法は、ロボットを任意の位置に動かして、シミュレーションを実行します。
任意に移動したロボットAの位置が初期位置に設定されます。
出力信号の詳細を確認する方法を説明します。
ロボットAをクリックして、[コンポーネントプロパティ]ウィンドウの[アクション設定]-[シグナルアクション]の出力から「1」を選択します。
信号1の詳細が表示されます。
初期設定の状態では信号1～100まではロボットプログラミングで使用します。
独自の信号を設定する場合は信号101以降を使用してください。
プルダウンから信号を選択するとそれぞれの信号のアクションを確認することが出来ます。
モーションステートメントの座標系を変更する方法を説明します。
サブプログラムを見ると[P1]，[P2]，[P3]の3つのポイントがあることが分かります。
[マニピュレーション]-[移動]を選択して[P3]を選択し移動します。
シミュレーションをリセットします。
シミュレーションを実行するとロボットAは部品を持ち上げた後に新しく設定した[P3]の位置に移動します。
シミュレーションをリセットします。
[マニピュレーション]-[ジョグ]を選択し、モーションプログラム[LIN P3]を選択すると、ロボットAが新しい[P3]の位置に移動することが確認できます。
ジョグモードでロボットAの位置を変更し、その位置を新しい[P3]としたい場合は
[プログラムエディタ]-[サブプログラム]-[タッチアップ]を選択します。
シミュレーションをリセットします。
シミュレーションを実行すると箱を持ち上げた後に新しい[P3]の位置に移動します。
シミュレーションをリセットします。
ロボットの交換について説明します。
ロボットAをロボットBに交換する場合に現在のロボットプログラムを引き継ぐ方法を説明します。
[ツール]-[ロボット入れ替え]を選択し、ロボットBを選択します。
[ロボットの入れ替え]-[ベース/ツール名の入れ替え]にチェックを入れ、適用を選択します。
ロボットAとロボットBが入れ替わります。
シミュレーションを実行するとロボットBがロボットAの時に設定した動作を行います。
ロボットツールの設定について説明します。
現在ロボットBは何もツールを付けないで箱を持ち上げています。
吸盤ツールをロボットBに設定します。
[ホーム]タブを開きます。
[eカタログ]の[タイプ別モデル]-[Robot Tools]-[Smart Suction Gripper]を選択します。
[マニピュレーション]-[PnP]が選択された状態で吸盤ツールをドラッグして、ロボットBのアームの先端に取り付けます。
シミュレーションをリセットします。
シミュレーションを実行すると吸盤ツールが箱に干渉してしまいます。
吸盤ツールと箱が干渉しないように設定します。
シミュレーションをリセットします。
[プログラム]タブを開きます。
[マニピュレーション]-[ジョグ]を選択しロボットBを選択します。
ctrlキーを押しながら3つのモーションステートメントを選択します。
[ステートメントプロパティ]ウィンドウの[Statements]-[Tool]から[GripperTcp]を選択します。
ロボットBの先端が吸盤ツールの先端に変更されます。
シミュレーションを実行すると吸盤ツールは箱に干渉しなくなります。
吸盤ツールで箱を持ち上げるために信号1の設定を変更します。
ロボットBを選択し、[コンポーネントプロパティ]ウィンドウの[アクション設定]-[シグナルアクション]-[出力]で「1」を選択します。
[つかむ]-[使用ツール]の値を「GripperTcp」に変更します。
シミュレーションをリセットします。
シミュレーションを実行すると、ロボットBが箱を持ち上げます。
再度ロボットを入れ替えます。
先ほどと同様に[ツール]-[ロボット入れ替え]を選択し、ロボットAを選択します。
[ロボットの入れ替え]-[ベース/ツール名の入れ替え]にチェックを入れ適用を選択します。
[出力]ウィンドウを確認すると、ロボットを交換する際の警告が表示されるため、必要に応じて動作設定に問題がないか確認してください。
ロボットBとロボットAが入れ替わりました。
シミュレーションを実行するとロボットAが箱を持ち上げます。
ロボットで箱をピックアップする方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットの動作にifを入れてみよう

ロボットの動作にifを入れて、条件分岐をさせる方法
https://youtu.be/1mz3T7dihqo
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_032.zip

ロボットプログラムのIFステートメントについて説明します。
IFステートメントを使用すると、その条件がTrueの場合の動作を定義できるようになります。
ロボットはステートメント内のプログラムを実行します。
条件がfalseの場合、ロボットは動作を実行せず次のステートメントを実行するため、
プログラミング言語の、if else thenと似た動作をします。
3Dワールドにロボットを追加します。
[プログラム]タブに移動し、[プログラムエディタ]で[Main]プログラムを編集します。
[IFステートメント]アイコンをクリックし、[Main]プログラムに追加します。
IFステートメントが、[Main]プログラムに追加されました。
IFステートメントは、ThenとElseの2つの範囲を設定することができます。
これらの範囲にステートメントを追加する場合は、
範囲を選択か条件タグであるThen、あるいはElseを選択します。
IFステートメントの範囲に、プリントステートメントを追加します。
プリントステートメントは、メッセージを[出力]ウィンドウに表示することができます。
Thenの場合は、「Hello World」と表示します。
Elseの場合は、Elseの範囲を選択し、
もう一度プリントステートメントを追加して、「Goodbye World」と表示します。
ステートメント条件がTrueの場合、IFステートメントのThenの範囲内にあるプログラムは実行されますが、
Elseの範囲内にあるプログラムは実行されません。
条件がFalseの場合、ステートメントのElseの範囲内は実行されますが、Thenの範囲内は実行されません。
シミュレーションを実行すると、[出力]ウィンドウに「Hello World」と表示されますが、
「Goodbye World」と表示するプログラムは、実行されませんでした。
シミュレーションをリセットします。
IFステートメントの条件を編集する場合、IFステートメントの[ステートメントプロパティ]で、編集することができます。
ステートメントプロパティに移動し、[コンディション]に条件式を入力できます。
条件一致すると、TrueまたはFalseの値が返されます。
値がTrueの場合、ステートメントのthenの範囲内を実行し、値がFalseの場合、Elseの範囲内を実行します。
[コンディション]をFalseに変更し、シミュレーションを実行します。
今回は、[出力]ウィンドウに「Goodbye World」と表示されました。
シミュレーションをリセットします。
画面右上のクエスチョンマークをクリックし、ヘルプファイルに移動することができます。
[リファレンスガイド]、[数式]を展開すると、式を書くために役立つトピックがいくつか見つかります。
ヘルプファイルを閉じます。
[コンディション]に0と入力すると、Elseの範囲内を実行できます。
1と入力すると、Thenの範囲内を実行することができます。
100と入力しても、Thenの範囲を実行します。
数式を入力することもできるので、「2+2==5」といった数式を入力すると、
回答が誤っているので、この条件はFalseの値を返し、Elseの範囲内を実行します。
Elseの範囲内にロボットの移動を追加します。
Elseの範囲を選択し、[各軸補間ステートメント]をクリックすると、Elseの範囲内に追加することができます。
リセットボタンでロボットを初期状態に戻し、シミュレーションを実行します。
条件の「2+2==5」がFalseだったので、ロボットはステートメントのElse範囲を実行しました。
シミュレーションをリセットします。
条件式には、論理演算子も使用できます。
[コンディション]の「2+2==5」は削除せず、2つの＆を追加すると、
必要な数の条件式を書くことができ、論理積を表しています。
「3+3==6」という数式を追加します。
「3+3==6」はTrueですが、「2+2==5」はFalseなので、IFステートメントはFalseの値を返します。
＆は両方の数式がTrueでなければ、IFステートメントはTrueの値を返しません。
同様に、論理和を使用できるため、2 つのパイプを入力します。
論理和は、これらの数式ののいずれかがTrueである場合、条件全体がTrueの値を返します。
「3+3==6」は、Trueなので、条件全体もTrueです。
シミュレーションを実行します。
ロボットが移動せず、「Hello World」と表示されました。
シミュレーションをリセットします。
算術演算子や条件演算子を使用する代わりに、ロボットのプロパティを使用できます。
3Dワールドでロボットを選択した場合、コンポーネントプロパティから、
ロボットのジョイントJ6、J1などを参照することができます。
IFステートメントに戻ります。
[コンディション]に「J1==90」と入力します。
J1が90の場合、Thenの範囲のTrueの値を返し、それ以外の場合はElseの範囲Falseの値を返します。
J1=90がTrueになるようにします。
IFステートメントを選択し、[ジョグ]ウィンドウを開き、ジョイントJ1を90に設定します
各軸補間ステートメントで位置を指定します。
[プログラムエディタ]で、各軸補間ステートメントがIFの前に来るように、IFステートメントの前に、ドラッグ＆ドロップします。
ロボットはP2に移動し、ジョイントJ1は90度になります。
IFステートメントが実行されると、条件がTrueになり、ロボットが「Hello World」を表示します。
シミュレーションをリセットし、実行します。
[出力]ウィンドウに、「Hello World」と表示されました。
シミュレーションをリセットしロボットを選択します。
コンポーネントプロパティで、タブのプロパティを参照する場合は、ここでタブをクリックします。
[Executor]タブをクリックすると、[Executor]には、2つプロパティがあります。
[有効です]にチェックがついており、Trueに設定されています。
IFステートメントに戻ります。
[コンディション]に「Executor::IsEnabled==True」と入力します。
条件がTrueの場合、thenの範囲を実行します。
シミュレーションを実行すると、「Hello World」と[出力]ウィンドウに表示されました。
次は、条件式のTrueをFalseに変更し、シミュレーションを実行します。
[コンデション]のTrueの部分をFalseに変更します。
「有効です」がFalseに設定されている場合、Thenの範囲を実行し、
「有効です」がTrueに設定されている場合、Elseの範囲を実行することができます。
シミュレーションを実行すると、ロボットはElseの範囲を実行しました。
シミュレーションをリセットします。
IFステートメントが属するサブルーチンの変数を参照する方法を説明します。
[プログラムエディタ]の[Main]をクリックし、ルーチンプロパティに移動します。
[新規変数を追加]から整数変数を選択し、[名称]をcountに変更します。
値は、現在は0に設定されています。
[プログラムエディタ]で、[変数割り当てステートメント]を追加します。
[ターゲットプロパティ]にcountを設定し、数式値は、そのまま0にしておきます。
次に、[WHILEステートメント]を追加し、IFステートメントをWHILEステートメントの中に入れます。
WHILEステートメントに対して、count変数の値が増加する設定をします。
もう1つ[変数割り当てステートメント]を追加し、countの現在の値に1を加えた値をcountに入れます。
それをWHILEステートメントの一番上に入れます。
[count=count+1]の下に遅延ステートメントを追加し、3秒遅延させます。
IF ステートメントでは、それが属するルーチンで countという変数を参照します。
[コンディション]にcount変数が5未満と入力します。
この条件がTrueの場合、Thenの範囲を実行し、
条件がFalseの場合、カウントが5以上であれば、Elseの範囲を実行します。
ロボットが動作してから、[出力]ウィンドウに「Hello World」を表示します。
ロボットを下に動かし、各軸補間ステートメントで、位置を指定します。
シミュレーションを実行すると、ロボットがP2に移動し、3秒遅延があり、条件はTrueなので、P3に移動しました。
実行中のステートメントは、[プログラムエディタ]で確認することができます。
遅延ステートメントを実行中に、シミュレーションを一時停止し、[Main]プログラムを選択します。
IFステートメントのElseの範囲なのでロボットがこの位置で停止します。
ルーチンプロパティでは、変数countの値が6なので、Elseの範囲を実行しました。
IFステートメントの使用方法説明は以上となります。
IFステートメントの使用例を簡単に説明します。
IFステートメントについて、練習としてこのレイアウトを使用してください
ロボットが、コンベアからワークをピックアップし、別のコンベアに置くという設定がされています。
IFステートメントの条件式には、ロボットの入力シグナルを使用しています。
ロボットを選択した状態で、[接続]グループの[シグナル]をクリックします。
コンベアセンサーの[SensorBooleanSignal]が、ロボットの入力シグナルと、接続されています。
入力シグナルの番号は100と101です。
[プログラムエディタ]で、[Main]プログラムにWHILEステートメントがあり、
IFステートメントが100の入力シグナルを参照しています。
100の入力シグナルがTrueの場合、このサブルーチンを呼び出し、緑色のワークを搬送します。
それ以外の場合は、ここに別のIFステートメントが設定されており、
入力シグナル101がTrueの場合は、このサブルーチンを呼び出し、ピンク色のワークを搬送します。
101がTrueではない場合、何もせず、遅延ステートメントを実行します。
シグナルエディタを非表示にし、シミュレーションを実行すると、
緑色のワークがセンサーに到達すると、100の入力シグナルがTrueので、ワークが搬送されます。
ピンク色のワークがセンサー到達すると、101の入力シグナルがTrueなので、
ワークが搬送されまが、緑色のワークだけを搬送します。
動作を修正します。
シミュレーションをリセットし、[Main]プログラムに戻ります。
現在、IFステートメントのElseの範囲内に別のIFステートメントがあります。
ロボットは、このElseの範囲内を実行しませんので、
Elseの範囲内にある、IFステートメントの場所を、変更します。
WHILEステートメントの中に移動し、ロボットの動作を確認します。
入力シグナル101がTrueになっているか確認します。
ピンクのワークを搬送するためのルーチンを呼び出し、その後、別のIFステートメントを実行します。
100の入力シグナルがTrueの場合、緑色のワークを搬送します。
シミュレーションを実行します。
ロボットが緑色のワークを搬送し、ピンク色のワークを搬送しました。
IFステートメントの使用例についての説明は以上となります。
IFステートメントの説明を終了します。

=================================================================================

ロボットの動作に条件をつけてみよう

ロボットの動作に条件をつける方法
https://youtu.be/Bs4Mp3MRhK8
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_025.zip

ロボットにIOを条件付き引数として使用する方法について説明します。
ロボットを選択し、[接続]グループの中の[シグナル]をクリックします、
[入力]と[出力]という名称のIOグループが設定されています。
シミュレーションを実行すると、コンポーネントが、このセンサー位置に到達するまで待機し、
コンポーネントがセンサー位置に到達したとき、[SensorBooleanSignal]の値をTrueにし、ロボットの[入力]200に通知します。
ロボットの[出力]201の値をTrueにし、コンベアモーターに送信し、[MotorSignal]をTrueにし、コンベアを停止させ、
コンポーネントを、ピックアップすることができるように設定します。
[Comveyor Motor]、[Feeder]、[Conveyor]、[Conveyor Sensor]が配置されています。
ロボットは、[Generic Articalated Robot]を使用していますが、eカタログの[Robots]の中から任意のもの配置します。
[Generic Articalated Robot]は、[Robots]の中の[VisualComponents]から配置しています。
[プログラム]タブをクリックしプログラムエディタを表示します。
プログラムエディタから[遅延ステートメント]を選択し、[ステートメントプロパティ]で[遅延]に0.1と入力します。
遅延ステートメントの下に追加するプログラムの実行を、設定した秒数だけ、遅延させることができます。
ロボットを選択し、コンポーネントプロパティの中から[Executor]タブを選択し、[ルーピング]にチェックをつけます。
ルーピングにチェックをつけると、プログラムエディタに表示されているプログラムをループさせます。
[シグナルアクション]タブをクリックし、[物理にリリース]から[If Target not Detected]を選択します。
[If Target not Detected]は、リリースする場所に何もない場合、つかんでいるコンポーネントをリリースする時に物理を付与します。
コンベアのシグナルがTrueになっているかどうかを確認します。
遅延ステートメントの下に[IFステートメント]を追加します。
[出力]200がTrueである場合、コンベアに接続されています。
モーターシグナルがTrueになっているので、[出力]200はTrueです。
追加した[IFステートメント]を選択し、ステートメントプロパティから、[コンディション]にOUT[200]と入力します。
[入力]を参照したい場合は、OUTの部分に、大文字でINと入力する必要があります。
[出力]200がTrueであるとき、コメントを残したい場合は、Thenを選択し、[プリントステートメント]を追加します。
ステートメントプロパティの[メッセージ]に入力すると、コメントを残すことができます。
シミュレーションを実行し、コンベアのシグナルがTrueになると、[出力]ウィンドウにコメントが表示されました。
シミュレーションをリセットします。
プログラムエディタに[WHILEステートメント]を追加し、
追加した[WHILEステートメント]を選択し、ステートメントプロパティの[コンディション]に、IN[200]!=0と入力します。
0はFalseを意味し、1はTrueを意味しています。
この[WHILEステートメント]は、[入力]200がFalseではないという条件を満たしている間、
WHILEステートメント内のプログラムを、繰り返し実行することができます。
WHILEステートメントの条件を満たしている場合、実行するプログラムを設定します。
最初に、コンベアを停止させます。
[セットバイナリ出力ステートメント]を追加し、
ステートメントプロパティの[バイナリ出力ステートメント]を200に変更し、出力値にチェックをがついていないことを確認します。
次に、コンポーネントがセンサー位置に到達したことを、[出力]ウィンドウに表示します。
[プリントステートメント]を追加し、[メッセージ]にPart Arrivedと入力します。
シミュレーションを再生します。
コンポーネントがセンサー位置に到達したとき、コンベアは停止し、[出力]ウィンドウにメッセージが表示されました。
ロボットがコンポーネントをピックアップし、空中でリリースするプログラムを作成します。
シミュレーションを実行し、スピードアップした場合、アクションを実行し続けることがわかります。
既存のIOを条件付き引数として使用してきましたが、より多くのIOグループが必要な場合があります。
新しいIOグループを作成します。
[モデリング]タブをクリックします。
[動作設定]グループの[ビヘイビア]をクリックし、展開します。
その中からブール型マップを追加します。
プロパティから[開始インデックス]がシグナル0であることを確認し、
[最終索引]をシグナル999に変更します。
0を含めると、1000個のシグナルを使用することが可能です。
[方向]でInputを選択します。
[方向]はシグナルマップを、インプットとアウトプットの、どちらとして使用するかを定義します。
[名前]の変更は任意ですが、ここでは[PickPart]と変更しておきます。
[プログラム]タブに戻ります。
[接続]グループの[シグナル]をクリックし、シグナルエディタを表示します。
ロボットの入力[200]の下に[PickPart]ポートが表示されていることが確認することができます。
コンベアセンサの[SensorBooleanSignal]と[PickPart]を接続します。
接続が完了したシグナルをダブルクリックし、200と入力し、
[入力]200から伸びている線をクリックし、[入力]と[SensorBooleanSignal]の接続を解除します。
新しいIOグループに接続されました。
入力[200]を使用していた条件式を変更します。
ロボットに設定済みの[WHILEステートメント]を選択し、
[コンディション]のINの部分を、PickPartに変更します。
[PickPart]200がFalseではない間、プログラムを繰り返し実行します。
シミュレーションを実行すると、ロボットがコンポーネントをピックアップし、空中でリリースしました。
IOを条件付き引数として使用する方法について説明の説明は以上となります。

=================================================================================

ロボットの動作を遅延させてみよう

ロボットの動作の間に、指定した時間の間は動作しない、遅延をさせる方法
https://youtu.be/YEzC0ZYaQFI
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_030.zip

遅延ステートメントの使用方法について説明します。
遅延ステートメントは、シミュレーション中にロボットプログラムの実行を、遅らせることができるステートメントです。
ロボットを使用するので、eカタログから配置します。
[タイプ別モデル]の下にある、[Robots]を展開し、[Visual Components]をクリックし、
[Generic Articulated Robot]をダブルクリックします。
3Dワールドの原点に、[Generic Articulated Robot]を配置しました。
[プログラム]タブに移動し、コマンド[ジョグ]にして、ロボットを選択します。
ロボットの[Main]プログラムに、遅延ステートメントを追加します。
[遅延ステートメント]をクリックすると、[Delay 0s]という項目が追加されます。
遅延ステートメントを使用することで、プログラムを秒単位で遅延させることができます。
ステートメントプロパティの[遅延]を2秒に設定します。
ミリ秒を使用する場合は、0.5と入力すると設定することができます。
今回は、2秒と設定し、遅延した後にロボットを移動させます。
ロボットの先端の矢印をドラッグし、移動した後に各軸補間ステートメントでその位置を指定します
プログラムエディタで、[各軸補間ステートメント]をクリックすると、
最初に遅延が発生し、ロボットがP1に移動します。
シミュレーションをリセットし、ロボットを初期状態に戻します。
シミュレーションを実行すると、ロボットが2秒間停止しP1に移動します。
シミュレーションをリセットします。
ロボットのシグナルを使用した、遅延ステートメントの方ほを説明します。
[ホーム]タブに移動します。
ロボットがモーターのシグナルのオンとオフを切り替え、モーターが制御しているコンベアのパスのオンとオフを切り替えます。
eカタログの[タイプ別モデル]の下にある、[Feeders]を展開し、
[Visual Components]をクリックし、[Basic Feeder]を3Dワールドにドラッグ＆ドロップして配置します。
フィーダーのインターフェースに、コンベアを接続します。
[タイプ別モデル]の下にある、[Conveyors]を展開し、
[Visual Components]をクリックし、[Conveyor]をドラッグ＆ドロップで追加します。
コマンド[PnP]を使用し、コンベアをフィーダーに接続します。
コンベアを制御するために、コンベアモーターを接続します。
eカタログの[Conveyor Utilities]をクリックし、[Conveyor Motor]をドラッグ＆ドロップで追加します。
コンベアモーターは、コンポーネントに接続すると、接続されたコンポーネントのパスを制御する設定がされています。
[PnP]を使用し、コンベアに接続します。
コンベアモーターをドラッグし、コンベアに近付けると、緑色の矢印が表示されます。
コンベヤに接続されると、青い矢印になります。
[PnP]が選択された状態で、モーターをパスに沿ってドラッグすると、モーターを別の位置に移動できます。
モーターに緑色の丸が表示されていますが、これはモーターがオンになっていることを意味しており、
オフになると、赤色に変化します。
シミュレーションを実行すると、コンポーネントが生成され、コンベアにに沿って移動します。
パスがオンになっているので移動することができます。
シミュレーションをリセットします。
パスのオンとオフを切り替えます。
モーターとロボットのシグナルを接続し、ロボットがシグナルを送信することで、
パスのオンとオフを切り替えることができます。
[プログラム]タブに移動します。
コマンド[ジョグ]が選択されていることを確認し、ロボットのプログラムを変更していきます。
[プログラムエディタ]のP1を削除します。
P1を選択した状態でdeleteキーまたは右クリックし、メニューから削除を選択することで、
ステートメントを削除することができます。
遅延ステートメントも削除し、最初からやり直します。
モーターとロボットのシグナルを接続するために、
[接続]グループの中にある、[シグナル]をクリックすると、シグナルエディタを表示することができます。
シグナルエディタの右上にある展開ボタンをクリックすると、表示、非表示を切り替えることができます。
[MotorSignal]横の丸をクリックしドラッグすると、ワイヤーを表示します。
ロボットの[出力]にカーソルを合わせると、緑色のチェックマークが表示され、シグナルをロボットの[出力]に接続できます。
接続したい出力に合わせてクリックをはなすことで、ロボットの[出力]0に接続されます。
ロボットのシグナル1から64は、コンポーネントの把持や解放などの、アクションが事前定義されているため、
新しくロボットのシグナルと接続する場合は、シグナル65から使用します。
シグナル番号を変更するので、シグナルエディタ[出力]の0をダブルクリックし、65と入力し、Enterキーを押すと、
モーターと接続されているシグナルが、[出力]65に変更されます。
もう一度[接続]グループの[シグナル]をクリックし、シグナルエディタを非表示にします。
ロボットからシグナルを送信するために、ロボットの[Main]プログラムに、[セットバイナリ出力ステートメント]を追加します。
ステートメントプロパティの[バイナリ出力ステートメント]を65に変更し、[出力値]のチェックボックスにチェックをつけません。
こうすることで、シミュレーションを実行すると、シグナル65の値がFalseの状態で出力します。
シミュレーションを一度リセットし、再度実行すると、
コンポーネントがコンベアに沿って移動せず、モーターの緑色の丸が赤色に変化しています。
オフにした後、パスをオンにするために、遅延ステートメントを追加します。
シミュレーションをリセットし、[遅延ステートメント]をクリックし、[Main]プログラムに追加します。
ステートメントプロパティの[遅延]に5と入力し、5秒遅延させます。
パスをオンにするために、[セットバイナリ出力ステートメント]をもう1つ追加します。
ステートメントプロパティの[バイナリ出力ステートメント]に65と入力し、
[出力値]のチェックボックスにチェックをつけ、値がTrueになるようにします。
シミュレーションを実行すると、開始時にパスがオフになり、5秒後にパスがオンになりました。
遅延ステートメントの使用方法についての説明は以上となります。

=================================================================================

ロボットプログラムでコメントとプリントを使ってみよう

ロボットプログラムに注釈を入れる方法と、シミュレーション実行中にメッセージを出力する方法
https://youtu.be/9T8CQ8s1_Ds
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_033.zip

コメントステートメントとプリントステートメントについて説明します。
コメントステートメントは、ロボットプログラムにメモやコメントを残すことができます。
多くのサブルーチンを呼び出している場合や、シグナルを待機または送信している場合、後でチェックして作業したり、プログラムを他の人と共有したりするときに、プログラムがどのように機能するかを、コメントとして残すことができます。
プリントステートメントは、コメントステートメントとは少し異なり、使用すると、[出力]ウィンドウにメッセージを表示できます。
ロボットを3Dワールドに配置し、使用してみます。
eカタログの[タイプ別モデル]の下にある[Robots]を展開します。
下にスクロールし、[Visual Components]をクリックし、[Generic Articulated Robot]を3Dワールドに追加します。
ロボットをプログラムするので、[プログラム]タブをクリックし、ロボットを移動させ、いくつかのステートメントを追加します。
[ジョグ]を使用し、ロボットを下に移動します。
[Main]プログラムに[各軸補間ステートメント]を追加し、ここにコメントを残すので、[コメントステートメント]を追加します。
ステートメントプロパティの[コメント]に、残したいコメントを入力することができます。
[コメント]に「Robot finished moving print feedback」と入力します。
プログラミング言語と同じように、複数のコメントを残すことができます。
明確で、読みやすいコメントを残します。
次に、プリントステートメントを追加します。
ステートメントプロパティの[メッセージ]に、表示したいメッセージを入力することができます。
[メッセージ]に「Robot is done,Give ne a new task.」と入力します。
ロボットの動作が終了すると、[出力]ウィンドウにメッセージを出力します。
シミュレーションをリセットし、実行すると、ロボットはP1まで移動し、コメントステートメントをスキップし、プリントステートメントを実行しました。
[出力]ウィンドウに、ロボットの名前とメッセージが表示されます。
コメントステートメントとプリントステートメントの使用例を説明します。
ワークがセンサーの位置に到達すると、ロボットが別のコンベアに搬送するようにプログラムしました。
プログラムエディタを確認すると、[Main]プログラムがシンプルになっています。
「Wait for part to reach sensor」というコメントを残します。
バイナリ入力待機ステートメントが入力シグナル100の値がTrueになるまで待機し、ワークを持ち上げるサブルーチンを呼び出します。
ワークを置くサブルーチンを呼び出し、ロボットがワークをコンベアに置くと、[出力]ウィンドウに「Picked and placed part」と出力します。
シミュレーションを実行すると、フィーダーからワークが生成され、ワークがセンサーに到達するまで、ロボットは待機し、ロボットがワークを持ち上げ、別のコンベアに置くと、メッセージが[出力]ウィンドウに表示されます。
シミュレーションを一時停止します。
このレイアウトにセンサー、コンベア、ロボットを追加する場合、構造が複雑になる可能性があるので、ロボットプログラムに、コメントやメッセージを追加するとわかりやすくなります。
コメントステートメントとプリントステートメントの使用例についての説明は以上となります。
コメントステートメントとプリントステートメントについての説明を終了します。

=================================================================================

ロボットプログラムでツール定義ステートメントを使ってみよう

ロボットの先端につけるツールをシミュレーション中に変更する時などに、ツールの中心位置の設定を変更する方法
https://youtu.be/E419CKNAgeo

ツール定義ステートメントの使用方法を説明します。
ツールフレームとはロボットなどが物体の位置決めに使用する基準点です。
ロボットにティーチングするためにツールフレームを使用します。
その際ロボットはツールフレームをツールセンターポイントTCPとして使用します。
ツール定義ステートメントはシミュレーション中にロボットのツールフレームの設定を変更することができシミュレーションをリセットすることでツールフレームの変更もリセットされます。
溶接機の手入れまたは塗装を行うとき使用することがあります。
ツール定義ステートメントの詳細はヘルプタブに移動後ヘルプボタンをクリックすることでヘルプファイルを開きます。
リファレンスガイドとロボットステートメントを展開しツール定義をクリックすることで確認することができます。
プロパティはベース定期ステートメントとほぼ同じです。
ヘルプファイルを終了します。
3Dワールドにロボットを配置し説明します。
[プログラム]タブに移動します。
[マニピュレーション]グループの[ジョグ]をクリックしロボットを選択します。
ロボットのツールフレームが表示されない場合3Dワールドツールバーにあるフレームタイプをクリックしロボットツールにチェックを付けます。
ツールフレームが表示されました。
ツールフレームのラベルサイズが小さい場合ファイルタブをクリックしオプションのディスプレイを選択します。
フレームラベルサイズを10から30に変更しOKをクリックすることでフレームのラベルサイズを変更することができます。
フレームのラベルサイズが大きくなりました。
ロボットのツールフレームはロボットの先端が初期位置です。
ツールフレームは[ジョグ]ウィンドウではワールド座標で表示されていますが、ツールフレームも独自のオブジェクト座標を持ち、ジョグパネルに移動しオブジェクトを選択することで確認することができます。
選択したロボットとツールフレームのオブジェクト座標で表示されています。
[ジョグ]ウィンドウのツールでツールフレーム位置を選択します。
ツールフレームの設定を変更する場合[ジョグ]ウィンドウのツールを設定しツールの右にある歯車アイコンをクリックします。
現在選択しているツールフレーム1を移動させます。
ツールプロパティではツールフレームの変換ができます。
ノードでは選択した別のノードと接続することができツールフレームはロボットのマウントプレートモードに接続されています。
ツール定義ステートメントを設定しツールフレーム位置をZ軸方向に移動します。
[プログラムエディタ]のメインルーチンにツール定義ステートメントを追加します。
ステートメントプロパティに移動し設定を変更するツールフレームを選択します。
ツールフレーム1を選択しツールフレーム1の親であるロボットのマウントプレートノードの座標を基準に移動させたい場合は[IsRelative]にチェックをつけます。
Z軸方向に300mm移動します。
シミュレーションを再生します。
ツールフレーム1が移動しシミュレーションをリセットすることで初期位置に戻りました。
接続するノードを変更します。
[ホーム]タブに移動しロボットにツールを接続するためeカタログのタイプ別モデルとRobot Toolsを展開しVisual Componentsをクリックします。
ロボットを選択した状態でWeld Torchをダブルクリックすることで3Dワールドに配置すると同時にロボットに接続することができます。
[プログラム]タブに戻りツールフレーム1を別のノードに接続する方法を説明します。
[ステートメントプロパティ]ではツールフレーム1の設定を変更しています。
座標Zの値を0に戻しノードをクリックしWeld Torch::TipNodeを選択します。
選択ボタンをクリックし3Dワールドから選択することもできますが。
溶接機のノードを3Dワールドから選択することは困難です。
シミュレーション中ツールフレーム1は溶接機からインポートしたツールフレームの位置に移動します。
シミュレーションを再生し確認します。
ツールフレーム1は移動していません。
[ジョグ]ウィンドウに移動します。
ツールでツールフレーム1が設定されていることを確認します。
シミュレーションをリセットしツール定義ステートメントを選択します。
IsRelativeにチェックが付いているためチェックを外します。
シミュレーションを再生し確認します。
ツールフレーム1が溶接機のツールフレームの位置に移動します。
シミュレーションを一時停止しツールフレーム1の位置を確認します。
[ジョグ]ウィンドウに移動しツールフレーム1はロボットのツールセンターポイントとして使用するため移動しましたが、シミュレーションをリセットすることでツールフレーム1は初期位置に戻り、接続しているノードもリセットされます。
ロボットにワークを持ち上げる設定をします。
[ホーム]タブに移動し溶接機を削除します。
eカタログのタイプ別モデルにあるProducts and Containersを展開しVisual ComponentsをクリックしCubeを3Dワールドにドラッグします。
サイズを変更するため[コンポーネントプロパティ]のCubeLengthを100に、CubeWidthとCubeHeightも100に変更します。
ロボットの届く距離にワークを配置します。
[プログラム]タブに戻り[ツール]グループの[スナップ]をクリックしロボットをワークの上面に移動させます。
ワークの上面をクリックし直線補間ステートメントを追加します。
ワークを把持するためセットバイナリ出力ステートメントを追加します。
バイナリ出力ステートメントに1を設定し出力値にチェックをつけます。
Z軸方向に移動し各軸補間ステートメントを2つ追加し各軸補間ステートメントでワークに接近する前の位置を指定するためメインルーチンの一番上にドラッグします。
シミュレーションをリセットし動作を確認します。
ワークを持ち上げました。
ツールフレームが移動する場合ツール定義ステートメントの設定を変更します。
シミュレーションをリセットしステートメントプロパティを編集します。
ワークの寸法は100×100×100のためZ軸方向に100mm移動します。
シミュレーションを再生します。
ツールフレーム1がワークの底面の位置に移動しました。
ロボットの移動経路を表示する方法を説明します。
3Dワールドでワークを削除し[プログラムエディタ]で全てのステートメントを削除します。
[ジョグ]ウィンドウに移動しツールフレーム位置が設定されていることを確認します。
ロボットを-Z軸方向に移動させ各軸補間ステートメントを追加しY軸方向に移動させ直線補間ステートメントを追加します。
ロボットがP1からP2に移動する前にセットバイナリ出力ステートメントを追加します。
バイナリ出力ステートメントに17を設定し出力値にチェックをつけます。
シミュレーションをリセットし再生します。
ロボットがP1からP2に移動し移動経路を表示しています。
移動経路の表示もツールフレーム1を移動させます。
シミュレーションをリセットしメインルーチンを選択しツール定義ステートメントをメインルーチンの一番上に追加します。
ステートメントプロパティに移動しツールフレーム1を設定します。
IsRelativeにチェックをつけ独自のオブジェクト座標を基準に移動します。
Z軸方向に100mm移動するため座標Zに入力する数値は100です。
ツールフレーム1を移動させた場合のP1からP2までの移動経路を確認します。
シミュレーションを再生します。
ツールフレーム1を移動させたことによりP1、P2とロボットの間の距離が変化しました。
ツールフレーム1の位置に基づきP1からP2に移動するためロボットとの間に距離があります。
シミュレーションをリセットしステートメントプロパティに戻りツールフレーム1の座標Zをリセットしシミュレーションを再生することでロボットとP1、P2との距離が元に戻りました。
シミュレーションをリセットします。
座標Zを100mmに設定することでロボットは100mm離れたP1からP2に移動します。
シミュレーションを再生します。
[プログラムエディタ]に戻りロボットがP1からP2に移動する前ツールフレーム1の位置を変更しています。
シミュレーションを再生し確認します。
ロボットはP1と100mm離れた状態で移動しP2とも100mm離れた状態で移動しました。
シミュレーションをリセットしツール定義ステートメントをP1の下にドラッグします。
動作を確認します。
P1に移動しツールフレーム1の位置を変更します。
P1からP2に移動するとき表示される経路を確認します。
シミュレーションをリセットし再生します。
ロボットがP1に到達後ツールフレーム1の位置を変更したためP1と100mm離れた位置からP2までに線を引きました。
ツール定義ステートメントの使用方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

ロボットプログラムでベース定義ステートメントを使ってみよう

ロボットが部品を積み上げる時などに、ロボットの動きの中心位置の設定を変更する方法
https://youtu.be/AAio_cQRkHQ
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_028.zip

ベース定義ステートメントの使用方法を説明します。
ベース定義ステートメントはシミュレーション中にべースフレームの設定を変更することができシミュレーションをリセットすることでベースフレームの変更を元に戻します。
ベース定義ステートメントの詳細はヘルプタブに移動しヘルプボタンからファイルを開き確認することができます。
リファレンスガイド、ロボットステートメントを展開しベース定義を選択します。
ベース定義ステートメントとプロパティの詳細を確認することができます。
[プログラム]タブに移動しジョグを使用しロボットを選択します。
[プログラムエディタ]には設定済みのサブルーチンが表示されています。
Mainルーチンにはサブルーチン「PickPart」を呼び出すステートメントが設定されています。
「PickPart」ではワークがセンサーに到達したときロボットがコンベアから持ち上げます。
「PlacePart」ではベース定期ステートメントを設定しワークをパレットに積み上げます。
メインルーチンに移動し「PickPart」を呼び出しベース定期ステートメントを追加します。
[ステートメントプロパティ]でロボットのベースフレームを選択し設定を変更するベースフレームを指定します。
ベースフレーム1を選択します。
[IsRelative]にチェックをつけることでステートメント実行時の位置に対しベースフレームを相対的に移動することができます。
チェックを外すことでノードで定義したベースフレームの位置を使用しベースフレームを絶対的に移動することができます。
ロボットはロボットワールドフレームにベースフレームが取り付けられています。
ベースフレームを移動する場合[ツール]グループの[ロボットワールドフレームを移動]をクリックしロボットワールドフレームの位置は確認できますがベースフレームは表示されません。
3Dワールドツールバーのフレームタイプをクリックしロボットベースにチェックをつけることでベースフレームを表示することができます。
ロボットワールドフレームを移動することでベースフレームも一緒に移動することを確認します。
コントロールキーとZキーを押し移動を元に戻します。
ロボットのベースフレームをパレットの位置に設定する方法を説明します。
[プログラムエディタ]に戻りベース定義ステートメントを選択します。
ステートメントプロパティに移動しパレットのノードに接続するベースフレームを設定します。
パレットのノードに接続するため3Dワールドからプロパティ値を選択ボタンをクリックし3Dワールドでパレットにカーソルを合わせると赤枠で囲われます。
パレットをクリックしノードでコンポーネント名が表示されることを確認することができます。
座標は使用しないため値を全て0にします。
シミュレーションを再生します。
ロボットがワークを持ち上げベースフレーム1がパレットの原点位置に移動します。
ベースフレームをパレットの角に移動します。
パレットのノード座標系を使用しベースフレーム1をパレットの角に移動することができます。
パレットを測定するため[ツール]グループの測定をクリックします。
スナップタイプを原点に変更しパレットの原点を選択します。
スナップタイプをエッジに変更しパレットの角を選択します。
原点からX軸方向に600、Y軸方向に400、Z軸方向に144という絶対値が得られました。
相対的な値を表示するために測定の設定でオブジェクトをクリックすることで3Dワールドと[出力]ウィンドウに値が表示されました。
オブジェクト座標ではベースフレームをX軸方向に-600、Y軸方向に-400、Z軸方向に144移動する必要があります。
[測定]ウィンドウを閉じステートメントプロパティに戻ります。
X軸方向に-600、Y軸方向に-400、Z軸方向に144と入力します。
ノード座標系を参照しベースフレーム1を移動します。
シミュレーションをリセットし再生します。
ワークを持ち上げベースフレーム1はパレットの角に移動しました。
シミュレーションをリセットしベースフレーム1が元の位置に戻ることを確認します。
ベース定期ステートメントを使用せずベースフレームの位置を変更できます。
[プログラムエディタ]に移動しベース定義ステートメントを削除します。
ジョグでロボットを選択します。
ジョグパネルに移動します。
ベースにBASE_1を設定後歯車アイコンをクリックしベースフレームを編集します。
ノードではベースフレームがロボット ワールドフレームに接続されていることが分かります。
3Dワールドからプロパティ値を選択ボタンをクリックします。
パレットを選択し座標で親をクリックします。
座標を一度すべて0にしベースフレームをパレットの原点に移動します。
測定した値を入力します。
X軸方向に-600、Y軸方向に-400、Z軸方向に144です。
ベースフレーム1はパレットの角に移動し固定します。
シミュレーションをリセットしてもベースフレームは元の位置には戻りません。
シミュレーションを再生します。
ワークを持ち上げベースフレーム1の位置はパレットの角にあります。
シミュレーションをリセットしロボットワールドフレームを移動でロボットワールドフレームを移動します。
ロボットワールドフレームを移動するときベースフレーム1のみロボットワールドフレームではなくパレットに接続されているため移動しません。
コントロールキーとZキーを押し元の位置に戻します。
パレットを移動します。
3Dワールドでパレットを選択し移動することでベースフレーム1がパレットと一緒に移動していることが確認できます。
コントロールキーとZキーを押し元の位置に戻します。
シミュレーションを再生します。
ベースフレーム1を参照しロボットがワークをパレットに配置する設定をします。
メインルーチンに移動しコールシーケンスステートメントを追加します。
PlacePartを呼び出す設定をします。
PickPartの下に移動します。
シミュレーションをリセットします。
PlacePartに移動し停止ステートメントを追加することでシミュレーションが停止します。
シミュレーションを再生し動作を確認します。
ワークを持ち上げPlacePartを呼び出します。
ワークをパレットに配置する位置はワークの角とパレットの角が揃う位置です。
ジョグをクリックし[ジョグ]ウィンドウに移動します。
ベースにベース_1を設定します。
[ツール]グループの[整列]をクリックします。
ワークの角を選択しベースフレーム1があるパレットの角と揃えます。
エスケープキーを押し整列を終了します。
ロボットにワークを配置する位置を設定します。
[プログラムエディタ]で直線補間ステートメントを追加します。
ワークを配置するためワークを開放するシグナルを出力します。
セットバイナリ出力ステートメントを追加後バイナリ出力ステートメントに1と入力し出力値のチェックはつけません。
ワークを解放後ロボットをZ軸方向に移動します。
直線補間ステートメントと各軸補間ステートメントを追加します。
ワーク解放後の位置と開放前の位置になるため各軸補間ステートメントをサブルーチンの一番上にドラッグします。
停止ステートメントは必要なくなったため削除します。
シミュレーションをリセットし再生します。
ロボットがワークを持ち上げワークを配置しました。
ワークに別のワークを積み重ねる設定をします。
ベースフレーム1を移動することでサブルーチンをシンプルにすることができます。
シミュレーションをリセットしメインルーチンに戻ります。
ベース定義ステートメントを追加します。
メインルーチンの一番下にドラッグします。
[ステートメントプロパティ]でベースフレーム1を設定します。
ベースフレーム1の3Dワールドでの現在の位置を取得しベースフレーム1を独自のオブジェクト座標を基準に移動します。
座標のXYZをリセットし[IsRelative]にチェックをつけます。
親座標では正確な座標を取得することはできないため独自のオブジェクト座標に基づき相対的に移動します。
100mm上に移動させるためZ200と入力します。
コントロールキーを押しながらメインルーチンのPickPartを呼び出すステートメントとPlacePartを呼び出すステートメントを選択しコピーします。
ベース定義ステートメントを選択しコピーしたステートメントを貼り付けます。
シミュレーションを再生し動作を確認します。
ワークを2つパレットに積み上げました。
ベースフレーム1を移動し別の位置にもワークを積み上げます。
シミュレーションをリセットしメインルーチンに戻ります。
2つ目のワークを配置した後にベース定義ステートメントを追加します。
ステートメントプロパティに移動しベースフレーム1を設定しパレットの角からX軸方向に移動します。
親座標に基づき移動します。
X座標に400を追加するため-600+400=-200になります。
メインルーチンでPickPartとPickPlaceを呼び出すステートメントを貼り付けます。
シミュレーションを再生します。
パレットの角に合わせ、ワークを2つ積み上げ隣にワークを一つ配置しました。
シミュレーションをリセットしもう一つワークを積み上げる設定をします。
メインルーチンに戻ります。
2つ目のワークを積み上げたときと同じことをするためベース定義ステートメントからPlacePartを呼び出すステートメントを選択します。
コピーし一番下のステートメントを選択後貼り付けます。
シミュレーションを再生し動作を確認します。
パレットの角に合わせワークを2つ積み上げ隣にワークを2つ積み上げました。
ベース定義ステートメントの使用方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

ロボットプログラムで同期ステートメントを使ってみよう

ロボットプログラムの実行を、他のロボットのプログラムと同期させる方法
https://youtu.be/5y2yFn8exIM
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_031.zip

同期ステートメントの使用方法を説明します。
同期ステートメントは他のロボットプログラムと同期させることができます。
1台のロボットを複数のロボットと同期させることができるためシミュレーション中ロボットの衝突を回避することもできます。
同期ステートメントの詳細は[ヘルプ]タブに移動し[ヘルプ]ボタンをクリックします。
リファレンスガイドロボットステートメントを展開し同期をクリックすることで確認することができます。
同期ステートメントは3つのプロパティを持ち同期コンポーネントは同期するコンポーネントを定義します。
ロボットが同期するコンポーネントはレイアウト内の他のロボットです。
同期メッセージでロボットが同期コンポーネントに送信するメッセージを定義することができます。
ロボットが同期ステートメントを実行することでメッセージを送信します。
同期待機はメッセージを送信した後すべての同期コンポーネントから同じメッセージを受信するまで次のステートメントの実行を待機するかを定義します。
ヘルプファイルを閉じます。
3Dワールドに任意の2台のロボットを配置します。
本動画ではオレンジのロボットと白いロボットを配置します。
[プログラム]タブに移動し[マニピュレーション]グループの[ジョグ]をクリックし最初にオレンジのロボットを選択し[プログラムエディタ]に移動します。
同期ステートメントを追加します。
[ステートメントプロパティ]でオレンジのロボットを白いロボットと同期させます。
同期コンポーネントの矢印ボタンと選択ボタンをクリックし3Dワールドで白いロボットを選択します。
同期メッセージをREADYに設定します。
オレンジのロボットは白いロボットからREADYというメッセージを受信するまで待機します。
オレンジのロボットを移動させ各軸補間ステートメントを追加します。
シミュレーションをリセットし白いロボットを選択します。
[プログラムエディタ]に移動し同期ステートメントを追加します。
[ステートメントプロパティ]で白いロボットとオレンジのロボットを同期させます。
同期コンポーネントの矢印ボタンと選択ボタンをクリックし3Dワールドでオレンジのロボットを選択します。
同期メッセージをREADYに設定し白いロボットとオレンジのロボットに同じメッセージを設定します。
シミュレーションを再生し動作を確認します。
オレンジのロボットはメッセージを送信し移動しました。
白いロボットが同じメッセージをオレンジのロボットに送信しましたが異なるメッセージを送信する場合の動作を確認します。
シミュレーションをリセットします。
白いロボットの同期ステートメントを選択しているため[ステートメントプロパティ]で同期メッセージをNOT READYに変更しシミュレーションを再生し動作を確認します。
オレンジのロボットが白いロボットにREADYというメッセージを送信し同じメッセージを受信するまで待機しているため動作しません。
白いロボットはREADYというメッセージを送信せずNOT READYというメッセージを送信したためオレンジのロボットは白いロボットと同期しません。
同期メッセージを元の状態に戻す以外の方法を説明します。
オレンジのロボットを選択し[プログラムエディタ]に移動し同期ステートメントを選択します。
白いロボットから同じメッセージを受信するまで待機する代わりに同期待機のチェックを外します。
オレンジのロボットはメッセージを送信し次のステートメントを実行します。
シミュレーションを再生し動作を確認します。
オレンジのロボットは移動しました。
シミュレーションをリセットします。
両方のロボットを同時に移動させる設定をします。
ステートメントプロパティに戻り同期待機にチェックをつけます。
白いロボットを選択します。
[プログラムエディタ]で同期ステートメントを選択します。
同期メッセージをREADYに変更しオレンジのロボットから送信されるメッセージと一致させます。
同期ステートメントの次に白いロボットを移動し各軸補間ステートメントを追加します。
シミュレーションをリセットし再生します。
両方のロボットが同期し移動しました。
同期ステートメントの使用方法についての説明は以上となります。
ご視聴いただきありがとうございました。

=================================================================================

ロボットプログラムに変数を追加してみよう

ロボットプログラムに変数を追加する方法
https://youtu.be/L3cbSBKgZLk
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_015.zip

ロボットプログラムを使用し、変数を追加および編集する方法を説明します。
eカタログに移動し、[タイプ別モデル]の[Robots]を展開し、[Visual Components]をクリックします。
[Generic Articulated Robot]を3Dワールドに追加します。
[プログラム]タブに移動します。
コマンド[ジョグ]を使用し、3Dワールドでロボットを選択します。
ロボットプログラムで使用できる変数に、ルーチン変数があります。
[プログラムエディタ]に移動することで、メインルーチンやサブルーチンなどのルーチンを、選択することができます。
ルーチンプロパティに移動します。
新しい変数を追加し、変数をブール型、整数、実数、文字列に設定することができます。
整数変数を追加することで、新しい名前に変更することができるので、名前をcounterに変更します。
変数の値を設定するので、変数を5に変更し、シミュレーションをリセットします。
変数が初期値にリセットされることが確認できます。
プログラムの開始時に変数の値を設定するため、[プログラムエディタ]に移動し、[変数割り当てステートメント]を追加します。
ルーチン変数を参照するステートメントと、同じルーチン内にある限り、変数に値を割り当てることができます。
ステートメントプロパティの[ターゲットプロパティ]にcounter、[数式値]に0と入力します。
ルーチン変数をWHILEステートメント、またはIFステートメントの条件式に使用することもできます。
[WHILEステートメント]を追加します。
[コンディション]にcounter<5と入力し、counterの値が5未満である限り、プログラムを繰り返し実行します。
[遅延ステートメント]を追加し、2秒遅延させます。
counterの現在の値に1加算するので、[変数割り当てステートメント]を追加し、[ターゲットプロパティ]にはcounter、[数式値]には変数の現在の値counterに1を加算します。
シミュレーション実行中、変数の値が割り当てられることを確認する場合、[プログラムエディタ]でメインルーチンを選択します。
ルーチンプロパティに移動し、変数の値が0であることを確認します。
シミュレーションを実行すると、1、2、3、4と値が増加していき、5に達するとロボットプログラムが終了し、シミュレーションが停止します。
シミュレーションをリセットすると、変数の値が0に戻ります。
変数を、別のルーチンで使用できないことを確認するため、メインルーチンとは別のサブルーチンを追加する必要があります。
[プログラムエディタ]に移動します。
新しいシーケンスを追加し、[変数割り当てステートメント]を追加します。
変数counterの値に0を割り当てます。
WHILEステートメントの下に、シーケンス1を呼び出すステートメントを追加し、シミュレーションを実行すると、メインルーチンでは、同じルーチン内の変数を使用しているため、counterの値を割り当てることができます。
ロボットプログラムがシーケンス1に到達すると、シミュレーションが停止し、[出力]ウィンドウにエラーメッセージが表示されます。
シーケンス1のプロパティには、変数counterが存在しないため、値を割り当てることはできません。
現在使用しているルーチン変数は、ローカル変数です。
シミュレーションをリセットします。
ロボットプログラムで、グローバル変数を使用する場合、コンポーネントプロパティを使用する方法があります。
3Dワールドでロボットを選択すると、[コンポーネントプロパティ]には、プロパティが表示されており、名前を使用し、参照することにより、WHILEステートメント、またはIFステートメントを使用してプロパティに値を割り当てることができます。
[プログラムエディタ]のメインルーチンを選択します。
WHILEステートメントと、シーケンス1を呼び出すステートメントを削除し、変数割り当てステートメントを編集します。
[コンポーネントプロパティ]のJ1に値を割り当てるため、[ターゲットプロパティ]をJ1、[数式値]を90に変更することで、J1を参照し、値を割り当てることができます。
ロボットの[コンポーネントプロパティ]に戻り、J1プロパティを表示します。
J1の現在の値は0です。
シミュレーションを実行すると、3Dワールドでロボットのジョイントが、別方向を向いたことを確認することができます。
[コンポーネントプロパティ]のJ1に90が割り当てられました。
シミュレーションをリセットすると、ロボットのジョイントが、初期値にリセットされ、J1が0に戻ることを確認します。
シミュレーションを実行し、コンポーネントの現在の状態を保存する場合、最初に、シミュレーションの[設定]ボタンをクリックし、次に、[状態の保存]ボタンをクリックします。
3Dワールドの現在のコンポーネントの状態が保存されます。
コンポーネントの[Kinematics]に移動すると、[パレタイジングモード]と[パレタイジングノーマル]の2つのプロパティが存在しています。
ロボットプログラムで値を割り当てる設定をします。
シミュレーションをリセットし、メインルーチンで、変数割り当てステートメントを編集します。
[ターゲットプロパティ]を変更し、[Kinematics]タブにあるプロパティを参照するので、Kinematics::PalletizingModeと入力します。
PalletizingModeの[数式値]にTrueと入力します。
別の変数割り当てステートメントを追加し、[ターゲットプロパティ]Kinematics::PalletizingNormalと入力します。
[数値式]では、ベクトルを渡す必要があり、式の記述にサポートが必要な場合、CtrlキーとSpaceキーを押し、オプションを取得します。
ベクトル関数を使用する必要があるので、Vと入力し、選択肢が表示されるので、Vectorをクリックし、(0,0,1)と入力します。
Enterキーを押し、エラーメッセージが表示さないことを確認します。
ロボットを選択し、[コンポーネントプロパティ]に移動し、パレタイジングモードにチェックはついておらず、値はFalse、パレタイジングノーマルは、Xは0、Yは0、Zは-1であることを確認します。
シミュレーションをリセットし、実行すると、パレタイジングモードの値をTrue、パレタイジングノーマルのZを1と割り当てられます。
シミュレーションをもう一度リセットすると、プロパティに変更した値が割り当てられるため、ロボットのジョイントのように、リセットされることはありません。
現在の設定を修正するには、メインルーチンまたはサブルーチンを、編集する必要があります。
メインルーチンの最初のステートメントを選択し、Ctrlキーを押しながら次のステートメントをクリックし、選択に追加します。
ステートメントをコピーし、シーケンス1に貼り付けます。
シーケンス1にあるcounterの値を0にするステートメントを、削除します。
パレタイジングモードの値を、Falseに、パレタイジングノーマルのZを、-1に変更します。
メインルーチンにシーケンス1を呼び出すため、メインルーチンに、[コールシーケンスステートメント]を追加し、メインルーチンの一番下にドラッグします。
プロパティは、グローバル変数なので、メインルーチンとサブルーチンで使用することができます。
[ステートメントプロパティ]でシーケンス1を選択することで、メインルーチンで呼び出します。
ロボットを選択し、シミュレーションをリセットします。
パレタイジングモードとパレタイジングノーマルの値を確認し、シミュレーションを実行すると、パレタイジングモードにFalseが、パレタイジングノーマルのZに-1が割り当てられます。
シミュレーションをリセットすると、変更した値が割り当てられた状態です。
ロボットプログラムの最後のステートメントは、シーケンス1にある、変数割り当てステートメントであり、パレタイジングノーマルのZに、-1が割り当てられます。
必要に応じ、プロパティをコンポーネントに追加し、ロボットプログラムで使用することができます。
[モデリング]タブに移動できる場合は、[モデリング]タブの中にある、[プロパティ]を展開すると、新しいプロパティを追加することができるので、ブール型プロパティを追加します。
画面右側のプロパティから、[名前]をExampleに変更します。
[名前]にRobotVariables::を追加し、Enterキーを押して、エラーメッセージが表示されないことを確認します。
RobotVariablesがグループ名、Exampleがプロパティ名です。
グループ名の変更は任意なので、RobotVariablesである必要はありません。
現在のExampleの値はFalseです。
コンポーネントグラフに移動し、プロパティを展開すると、ロボットに設定済みのプロパティが表示されます。
[ホーム]タブに戻り、ロボットを選択し、[コンポーネントプロパティ]に、RobotVariablesが追加されたことを確認します。
[プログラム]タブに移動し、[プログラムエディタ]から、メインルーチンを選択します。
ベクトルを割り当てるステートメントと、シーケンス1を呼び出すステートメントを削除し、追加したプロパティExampleの値を割り当てます。
変数割り当てステートメントを選択し、ステートメントプロパティの[ターゲットプロパティ]にRobotVariables::Exampleと入力します。
[数式値]をTrueに設定します。
ロボットを選択し、[コンポーネントプロパティ]のExampleがFalseであることを確認し、シミュレーションを実行すると、ExampleにTrueが割り当てられます。
シミュレーションをリセットし、値がリセットされないことを確認します。
[モデリング]タブに移動できない場合、Python、または.net APIを使用し、変数を追加します。
スクリプトを使用し、ロボットにより実行されるVCプログラムに、変数を追加する方法を説明します。
[モデリング]タブに移動し、[動作設定]グループにある[ビヘイビア]を展開し、[パイソンスクリプト]を追加します。
表示されるパイソンスクリプトに記述します。
Ctrlキーとプラス記号を押すと、テキストを拡大でき、Ctrlキーとマイナス記号を押すと、テキストを縮小することができます。
1行目以外は必要ないので、削除します。
スクリプトを含むコンポーネントの、情報を取得するため、comp=getComponent()と記述します。
getComponentはVCスクリプトに含まれているため、VCスクリプトからすべてをインポートしています。
コンポーネントを取得し、変数に割り当てます。
ロボットエグゼキューターの情報を取得するので、robotExecutor=comp.findBehaviour("Executor")と記述します。
findBehaviourは、コンポーネントパネルからビヘイビアを参照するための記述です。
robotProgram=robotExecutor.Programと記述します。
VCプログラムには、新規変数を作成するためのメソッドがあります。
prop=robotProgram.createProperty(VC_INTEGER,"counter")と記述し、整数型の変数counterを作成します。
変数の名前を渡すため、このカウンターを呼び出します。
変数に名前を付け、ロボットプログラムで参照することができます。
スクリプト、またはAPIを使用し、新規プロパティを作成する場合、変数を作成するとき、または初期化するとき、変数の制約を渡す必要があります。
GUIを使用し、変数を追加し、変数を選択することもできます。
[プロパティ]ウィンドウから制約を編集することができるので、ブール型変数の制約はあまりありません。
文字列変数の場合、制約があるので、GUIを使用し、編集できます。
スクリプトで変数を作成する場合、制約を定義する必要があります。
コードをコンパイルし、[出力]ウィンドウにエラーメッセージが表示されないことを確認します。
[プログラム]タブに移動します。
メインルーチンを選択し、変数counterが既に存在しているので、削除します。
メインルーチンの変数割り当てステートメントを削除、または編集します。
counterに値を割り当てるため、変数割り当てステートメントを編集します。
[ターゲットプロパティ]にcounter、[数式値]に0と入力します。
WHILEステートメントを追加します。
counterが5未満である限り、ステートメントを繰り返し実行するため、[コンディション]にcounter<5と入力します。
[遅延ステートメント]を追加後、2秒に設定し、ドラッグ＆ドロップでWHILEステートメント内に移動させます。
[変数割り当てステートメント]を追加し、[ターゲットプロパティ]にcounter、[数式値]にcounter+1と入力します。
シミュレーションを実行します。
ルーチン変数ではないため、変化しません。
変数割り当てステートメント実行後、IFステートメントを実行するため、追加します。
[コンディション]にcounter%2==0と入力し、counter の値が偶数の場合、ロボットを移動させます。
各軸補間ステートメントを、thenの範囲に追加します。
counterが奇数の場合は、ロボットは動作しません。
シミュレーションをリセットし、実行します。
ロボットが動作し、シミュレーションが停止しました。
counterが奇数の場合、ロボットが別の場所に動作する設定をします。
ロボットを移動させ、各軸補間ステートメントをElseの範囲に追加します。
counterが偶数の場合P1へ、奇数の場合P2へ移動します。
シミュレーションをリセットし、実行します。
ロボットは移動し、P1、P2と交互に移動しました。
ロボットプログラムを使用し、変数を追加および編集する方法についての説明は以上となります。

=================================================================================

ロボットプログラムのエクスポートとインポートをしてみよう

ロボットプログラムをXML形式でエクスポートし、別のロボットにインポートする方法
https://youtu.be/5Wlfxojabb4
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_142.zip

ロボットプログラムのエクスポートとインポートの方法を説明します。
[Export and Import Robot Program_before.vcmx]をダウンロードし、開きます。
ロボットのモーションを確認します。
[プログラム]タブを開きます。-[マニピュレーション]-[ジョグ]を選択しロボットを選択します。
[プログラムエディタ]ウィンドウにモーションステートメントが表示されます。
モーションプログラムを順番にクリックするとロボットが移動します。
シミュレーションをリセットします。
シミュレーションを実行すると、ロボットが箱を持ち上げてパレットに置きます。
ロボットのプログラムをエクスポートして、新しいロボットにインポートする方法を説明します。
既存のロボットをロボットA、新しいロボットをロボットBとします。
ロボットAのプログラムをエクスポート（保存）します。
[プログラムエディタ]ウィンドウの-[サブプログラム]から[プログラムのエクスポート]を選択し、ファイル名を入力して保存をクリックします。
今回は[Pick & Place]という名前で任意の場所に保存します。
ロボットBを配置します。
[ホーム]タブを開きます。
[eカタログ]の[タイプ別モデル]-[Robots]-[Mitsubishi Electric]-[RV-20FR]を選択して、画面上へドラッグして配置します。
吸盤ツールをロボットBに取り付けます。
[マニピュレーション]-[PnP]が選択された状態で吸盤ツールをドラッグして、ロボットBのアームの先端へ取り付けます。
ロボットAと吸盤ツールの向きが変わりましたがセットアップが完了するまでこのままにしておきます。
ロボットBの位置を移動してロボットAの位置に重ねます。
ロボットBを選択した状態で[ツール]-[スナップ]を選択して、[コンポーネントスナップ]-[スナップタイプ]-[原点]を選択します。
ロボットAのベース部分を選択すると原点に配置されます。
ロボットAをロボットBの可動範囲外に移動します。
[マニピュレーション]-[移動]を選択し、ロボットAを移動します。
ロボットAのモーションを無効に変更します。
[コンポーネントプロパティ]ウィンドウの[Executor]タブ-[有効です]のチェックを外してください。
ロボットBにロボットAのプログラムをインポートします。
[プログラム]タブを選択します。
ロボットBを選択します。
[プログラムエディタ]-[サブプログラム]の[プログラムをインポート]を選択します。
先ほど作成したプログラムファイルを選択し、[開く]を選択するとロボットBにモーションが読み込まれます。
この状態でシミュレーションを実行すると吸盤ツールが箱に干渉してしまいます。
吸盤ツールと箱が干渉しないように設定します。
シミュレーションをリセットします。
フレームタイプから[ロボットツール]と[ロボットポジション]の表示をONにします。
表示名のサイズを変更したい場合は、オプションでサイズを変更できます。
[ファイル]タブを開きます。
[オプション]-[ディスプレイ]を選択し、[フレームラベルサイズ]を任意の数字にします。
今回は、「17」と入力し、[OK]ボタンをクリックすると、表示名が大きくなっていることがわかります。
[マニピュレーション]-[ジョグ]を選択した状態でロボットBを選択します。
[ジョグ]ウィンドウを選択し、[ジョグ]-[Robot]-[ツール]を選択し、プルダウンから[Tool1]を選択し、右側の歯車マークを選択します。
[ツール]-[スナップ]を選択し、[ツールスナップ]-[スナップタイプ]から[フレーム]を選択します。
吸盤ツールの座標（GripperTCP）を選択することで、ツールの先端がGripperTCPに設定されます。
次に吸盤ツールの角度をロボットAの角度に合わせます。
[マニピュレーション]-[ジョグ]を選択した状態でロボットBを選択します。
[ジョグ]ウィンドウを選択し、[ジョグ]-[ジョイント]の[J5]の値を[90]に変更します。
この状態を初期状態として登録します。
シミュレーション再生ボタンの左側にある歯車を選択し、状態の保存をクリックします。
シミュレーションを実行するとロボットAと同じ動作を行います。
ロボットプログラムのエクスポートとインポートの方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットプログラムをPythonで記述してみよう(1/2)

ロボットをパイソンスクリプト（Python）を用いて制御して、移動させる方法（VC_ROBOTEXECUTOR）
（関連動画：ロボットをPythonで制御しよう(1/3)）
https://youtu.be/ZK3WMZL5ROI
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_141_p1.zip

ロボットプログラムを記述する方法を説明します。
Pythonスクリプトでロボットプログラムを記述し、動作を制御します。
パート1では、ロボットを指定した位置に移動します。
eカタログの[タイプ別モデル]-[Robots]-[Mitsubishi Electric]を開きます。
[RV-13FL]を追加します。
[モデリング]タブを開きます。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
[プログラム]タブを開きます。
プログラムエディタのサブプログラムに、パイソンスクリプトを使用して、ステートメントやルーチンを追加します。
3行目以下のソースコードは不要なため、削除します。
「comp = getComponent()」と記述し、Pythonスクリプトを設定しているコンポーネントを取得します。
「robotExecutor = comp.findBehavioursByType」と記述し、コンポーネント内の指定したタイプのビヘイビアを取得します。
[モデリング]タブを開き、[コンポーネントグラフ]ウィンドウのビヘイビアを確認すると、Executorがあることがわかります。
今回は、ロボットのExecutorを取得するため、「VC_ROBOTEXECUTOR」と記述します。
ロボットエグゼキュータを使用すると、ロボットプログラムの読み出しや、書き込み、実行ができます。
findBehavioursByTypeは、対象のビヘイビアをリストとして取得するため、0と記述し、0番目のエグゼキュータのみ取得します。
[プログラム]タブを開きます。
[サブプログラム]-[Main]にステートメントを追加します。
「robotProgram = robotExecutor.Program」と記述し、ロボットプログラムの情報を取得します。
「mainRoutine = robotProgram.MainRoutine」と記述し、メインルーチンの情報を取得します。
「statement = mainRoutine.addStatement」と記述し、メインルーチンに指定したステートメントを追加します。
今回は、プリントステートメントを追加するため、VC_STATEMENT_PRINTと記述します。
「statement.Message = "Hello World"」と記述し、プリントステートメントで表示するメッセージをHello Worldにします。
コンパイルボタンをクリックします。
[サブプログラム]-[Main]を確認すると、Hello Worldというメッセージのプリントステートメントが追加されていることがわかります。
プリントステートメントの前に遅延を追加します。
「statement = mainRoutine.addStatement(VC_STATEMENT_DELAY)」と記述し、遅延ステートメントを追加します。
遅延ステートメントをプリントステートメントの前に追加したいため、0と記述し、0番目に追加します。
番号を指定しない場合は、各ステートメントの一番後ろに追加されます。
「statement.Delay = 2.0」と記述し、2秒間遅延させます。
コンパイルボタンをクリックします。
[サブプログラム]-[Main]を確認すると、一番初めに遅延ステートメントが2秒間追加されていることがわかります。
プリントステートメントも再度追加されていることがわかります。
ステートメントが再度追加されないように、パイソンスクリプトを修正します。
ステートメントを追加する前に、メインルーチンを削除します。
mainRoutine.clear()と記述し、メインルーチン内のステートメントを削除します。
コンパイルボタンをクリックします。
[サブプログラム]-[Main]を確認すると、メインルーチン内のステートメントが削除され、追加したステートメントのみ表示されていることがわかります。
ステートメントを追加し、ロボットを動かします。
「statement = mainRoutine.addStatement(VC_STATEMENT_PTPMOTION)」と記述し、各軸補間ステートメントを追加します。
[各軸補間ステートメント]は、ロボットの位置を記録し、ジョイントの値を補間して動かすことができます。
各軸補間ステートメントや直線補間ステートメントを追加する場合は、デフォルトで位置が設定されています。
デフォルトで位置が設定されていることを確認するため、「print statement.Positions」と記述し、位置を[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[サブプログラム]-[Main]を確認すると、PTP P1という名前の各軸補間ステートメントが追加されていることがわかります。
[出力]ウィンドウを確認すると、各軸補間ステートメントの位置がリストで表示されています。
PTP P1を選択すると、ロボットがデフォルトで設定されている台座の中心の位置に移動します。
シミュレーションをリセットします。
PTP P1に移動先の位置を設定します。
print関数は不要なため、削除します。
「position = statement.Positions[0]」と記述し、PTP P1のデフォルトの位置を取得します。
デフォルトの位置は、ロボットの台座の中心を原点とした座標系で取得しています。
移動先は、ワールド座標系で指定するため、ワールド座標系における位置を取得します。
「pos_matrix = position.PositionInWorld」と記述し、ワールド座標系におけるデフォルトの位置を取得します。
ワールド座標系がどのタイプで取得されているか確認するため、print pos_matrixと記述し、位置を[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、位置がマトリックスで取得されています。
マトリックスとは、行や列のことです。
オブジェクトの位置や方向が行や列で取得されていることがわかります。
デフォルトの位置を基準にして、移動先をx、y、Z軸のマトリックスで相対的に指定します。
print関数は不要なため、削除します。
pos_matrix.translateRelと記述し、デフォルトの位置を基準にして、指定した位置まで移動します。
X軸方向に1000mm、Y軸方向に0mm、Z軸方向に1000mm移動します。
position.PositionInWorld = pos_matrixと記述し、移動先の位置をワールド座標系に変更し、新しい位置として設定します。
コンパイルボタンをクリックします。
PTP P1を選択すると、ロボットが新しい位置に移動します。
今回はロボットの台座の中心に原点があったため、xが0+1000で1000mm、zが0+1000で1000mmに位置が設定されたことがわかります。
ロボットの先端を確認すると、+Z軸方向を向いています。
ロボットの先端が-Z軸方向を向くように設定します。
ロボットの位置設定の後に、回転を設定します。
pos_matrix.rotateRelY(180.0)と記述し、Y軸を基準に180度回転します。
コンパイルボタンをクリックします。
PTP P1を選択すると、ロボットの先端が-Z軸方向に向いていることがわかります。
パート1の説明は以上となりますが、ファイルを保存する場合は、OnRun関数やOnStart関数を作成し、4行目以下のソースコードを入れてください。
関数を使用せずにファイルを保存して再度開くと、コードが実行されますが、コンポーネントの全ての情報を即座に読み取ることができずエラーが発生します。
そのため、OnRun関数やOnStart関数を使用して、ファイルを読み込む際にコードをすぐに実行しないことで、エラーを回避できます。
一括でインデントを入れるには、インデントを入れたい行を選択し、tabキーを押します。
ロボットプログラムを記述し、ロボットを指定した位置に移動する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットプログラムをPythonで記述してみよう(2/2)

ロボットをパイソンスクリプト（Python）を用いて制御して、サブルーチンを作成する方法
（関連動画：ロボットをPythonで制御しよう(1/3)）
https://youtu.be/CPKTn_ShoQQ
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_141_p2.zip

ロボットプログラムを作成する方法を説明します。
パート1では、ロボットを指定した位置に移動しました。
パート2では、ロボットが箱を持ち上げる前の移動と、サブルーチンを追加します。
パート1で使用したファイル、もしくは、[Write Robot Program - Layout_Part1_after.vcmx]をダウンロードし、開きます。
箱を追加します。
eカタログの[タイプ別モデル]-[Products and Containers]を開きます。
[cube]を追加します。
パイソンスクリプトで、ロボットの先端を箱の上面中央に移動します。
[モデリング]タブを開きます。
[コンポーネントグラフ]ウィンドウの[RV13FL]-[ビヘイビア]-[PythonScript]を開きます。
def OnRun関数を削除し、関数内のソースコードのインデントを1つ左にします。
一括でインデントを1つ左にするには、インデントを削除したい行を選択し、shiftキーを押しながら、tabキーを押します。
[プログラム]タブを開きます。
[サブプログラム]-[Main]のPTP P1を箱の上面中央の位置に設定します。
21行目と22行目をコメントアウトします。
箱の位置を取得します。
app = getApplication()と記述し、アプリケーション情報を取得します。
cube = app.findComponent("Cube")と記述し、箱を取得します。
pos_matrix = cube.PositionMatrixと記述し、箱の原点の位置情報をマトリックスで取得します。
箱の原点は、[マニピュレーション]-[移動]を選択した状態で箱を選択すると、ピンク色の丸で表示されます。
箱の位置を直接指定しており、20行目は不要なため、コメントアウトします。
コンパイルボタンをクリックします。
[マニピュレーション]-[ジョグ]を選択し、PTP P1を選択すると、ロボットが箱を突き抜けます。
箱の底面中央にロボットが移動したため、箱の底面中央にある原点の位置情報を取得していることがわかります。
シミュレーションをリセットします。
ロボットの先端が箱の上面中央に移動するように設定します。
cube_center = cube.BoundCenterと記述し、箱の原点から箱の中心点までのベクトルを取得します。
今回は、箱の上面中央の位置を指定するため、中心点から更に+Z軸方向に移動します。
pos_matrix.translateRelと記述し、箱の底面中央にある原点の位置に対して、指定した位置に移動します。
X軸方向は、cube_center.Xと記述し、箱の中央にします。
Y軸方向は、cube_center.Yと記述し、箱の中央にします。
Z軸方向は、cube_center.Z*2と記述し、箱の原点から中心点までの距離の、2倍離れた位置、つまり、上面にします。
22行目をコピーして、29行目に貼り付けます。
コンパイルボタンをクリックします。
PTP P1を選択すると、ロボットの先端が箱の上面中央に移動します。
セットバイナリ出力ステートメントや各軸補間ステートメントを追加することで、箱を持ち上げることができます。
箱を持ち上げる動作は、「ロボットをPythonで制御しよう」をご参照ください。
ロボットプログラムにサブルーチンを追加します。
subroutine = robotProgram.addRoutineと記述し、サブルーチンを追加します。
名前はExampleにします。
コンパイルボタンをクリックします。
[サブプログラム]を確認すると、Exampleという名前のサブルーチンが追加されていることがわかります。
Exampleのサブルーチンにステートメントを追加します。
17行目と18行目をコピーして、33行目に貼り付けます。
mainRoutineをsubroutineに変更し、各軸補間ステートメントを追加します。
箱の上面中央のマトリックスは24行目～30行目で取得しているため、取得した位置を新しい位置として設定します。
position.PositionInWorld = pos_matrixと記述し、新しい位置をワールド座標系に変更します。
コンパイルボタンをクリックします。
[出力]ウィンドウにエラーが表示されます。
Exampleのサブルーチンは一度コンパイルして作成済みのため、同じ名前が追加できずエラーが発生します。
違う名前のサブルーチンを作成します。
ExampleをExmaple 2に変更します。
コンパイルボタンをクリックします。
[サブプログラム]を確認すると、Example 2という名前のサブルーチンが追加されています。
Example 2には、PTP P2という名前の各軸補間ステートメントが追加されています。
PTP P2を選択すると、ロボットの先端が箱の上面中央に移動するため、PTP P1と同じ位置が取得できていることがわかります。
同じ名前のサブルーチンにステートメントを追加してもエラーが発生しないように設定します。
subroutine = robotProgram.findRoutineと記述し、ルーチンを取得します。
今回はExample 2を取得します。
if subroutine:と記述し、Example 2のサブルーチンが存在する場合の条件を設定します。
subroutine.clear()と記述し、Example 2のサブルーチンが存在する場合、サブルーチンを削除します。
if not subroutine:と記述し、Example 2のサブルーチンが存在しない場合の条件を設定します。
Example 2のサブルーチンが存在しない場合は、サブルーチンを追加するため、37行目をif not subroutineに入れます。
コンパイルボタンをクリックします。
[出力]ウィンドウにエラーが表示されていません。
Example 2が既にあるため、一度削除され、再度Example 2のサブルーチンが追加されたことがわかります。
PTP P2を選択すると、箱の上面中央に移動します。
MainルーチンとExample 2のサブルーチンにはステートメントがありますが、Exampleのサブルーチンにはステートメントがありません。
ExampleにExample2のステートメントを作成し、Example2を削除します。
10行目にfor subroutine in robotProgram.Routines:と記述し、ロボットプログラム内のサブルーチンをsubroutineという変数に代入します。
robotProgram.deleteRoutine(subroutine)と記述し、ロボットプログラム内のサブルーチンを削除します。
9行目でメインルーチン内のステートメントを削除し、10行目と11行目でサブルーチンを削除しています。
そのため、最初はサブプログラム内が空のメインルーチンのみの状態になります。
13行目～32行目でメインルーチンにステートメントを追加します。
34行目～42行目でExample2のサブルーチンとステートメントが追加されるため、Exampleのサブルーチンとステートメントが追加されるように変更します。
34行目と38行目のExample 2をExampleに変更します。
コンパイルボタンをクリックします。
[サブプログラム]を確認すると、メインルーチンにステートメントが追加されています。
ExampleのサブルーチンとPTP P2が追加され、Example 2のサブルーチンが削除されたことがわかります。
パート2の説明は以上となりますが、ファイルを保存する場合は、OnRun関数やOnStart関数を作成し、5行目以下のソースコードを入れてください。
ロボットプログラムを記述し、ロボットが箱を持ち上げる前の移動とサブルーチンを追加する方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットプログラムをWhileを使ってループさせてみよう

ロボットプログラムをWhileを使ってループさせることで、同じ動作を繰り返し実行させる方法
https://youtu.be/Z3ufFcqDXX0
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_022.zip

ロボットプログラムを繰り返し実行する方法を説明します
3Dワールドにフィーダー、コンベア2つ、ロボットを配置します
[プログラム]タブに移動し[マニピュレーション]グループの[ジョグ]を使用し3Dワールドでロボットを選択します
[プログラムエディタ]ではロボットに設定済みのプログラムを表示することができます
Mainルーチンにロボットがボックスをピックアップするサブルーチンとボックスをプレイスするサブルーチンを呼び出しています
シミュレーションを再生します
ボックスがコンベアの端に到着後ロボットがピックアップしプレイスします
ロボットプログラムが終了したのでシミュレーションが停止します
再度シミュレーションを再生するとロボットプログラムは完了しているため動作しません
ロボットがボックスのピックアップとプレイスを繰り返すロボットプログラムの設定をします
ロボットを選択し[コンポーネントプロパティ]に移動します
[Executor]タブを選択し[ルーピング]にチェックを入れオンにします
[ルーピング]は実行するプログラムをオンの場合は繰り返し実行しオフの場合は1回実行し ます
シミュレーションを再生します
ロボットはボックスのピックアップとプレイスを繰り返し実行します
シミュレーションをリセットしシミュレーションの設定ボタンをクリックします
[繰り返し]はシミュレーションを繰り返し再生するオプションです
[繰り返し]にチェックを入れルーピングのチェックを外します
シミュレーションを再生します
シミュレーションが再生されロボットプログラムが完了するとリセットされ再度再生します
ロボットプログラムを一度のみ実行することを繰り返しています
シミュレーションをリセットし[ルーピング]にチェックを入れます
[ルーピング]はロボットプログラムを繰り返しているためシミュレーションが停止することもリセットすることもありません
シミュレーションの設定から[繰り返し]のチェックを外し[Executor]タブの[ルーピング]のチェックを外します
ロボットプログラムを繰り返す他の方法を説明します
WHILEステートメントを使用しプログラム内にループを作成する方法です
[プログラムエディタ]に移動しMainルーチンに3つのステートメントが設定さ れていることを確認します
WHILEステートメントを追加しWHILEステートメント内に3つのステートメントを移動します
WHILEステートメントにドラッグアンドドロップすることでステートメント内に移動させることができます
WHILEステートメントはコンディションがTrueとなっているためループを常に実行します
シミュレーションを再生します
[ルーピング]設定は外していますがプログラム内にループがあるためプログラムが終了することはなくロボットがピックアップとプレイスを繰り返してい ます
ロボットの[コンポーネントプロパティ]を表示し[ルーピング]にチェックが入っていないことを確認します
シミュレーションをリセットします
ループから抜ける方法を説明します
ループを実行するための条件の値を Falseに変更することでWHILEステートメントを終了することができます
WHILEステートメントの下にプリントステートメントを追加します
WHILEステートメントが終了したことを知らせるためメッセージにexit whileループと入力します
WHILEステートメントを選択しステートメントプロパティのコンディションにTrue、またはFalseの値を返す式を記述します
式がTrueの値を返す場合ループが実行されFalseの値を返す場合ループは実行されません
[コンディション]に「False」と入力します
シミュレーションを再生します
ロボットは動作しません
ボックスをピックアンドプレイスする条件はFalseであるため実行せずロボットプログラムを終了し[出力]ウィンドウにはメッセージが出力されています
ロボットの入力ポートを参照し条件式を記述します
別のコンポーネントからシグナルを受信する場合大文字で「IN」と記述し括弧[ ]内にポート番号を記述します
コンディションにIN[105] ==Falseと記述することで入力ポート105がFalseである限りループを実行します
別の表現としてIN[105] != Trueと記述することもできます
現状の条件に別の条件を追加します
| (パイプライン)を2つ並べたor演算子を使用することで 条件へまたは条件Bという条件式を作成することができます
コンディションに || IN[101]==Falseと追記します
いずれかの条件を満たしている限りループを実行します
|を&に変更することで両方の条件を満たしている限りループを実行する条件式に変更することができます
ジョイントJ1を使用し条件式を記述するためロボットのジョイントJ1が90未満である限りループを実行します
[WorkSpace]タブの[Envelope]がFalseである限りループを実行するため「WorkSpace::Envelope !=True」と記述します
シミュレーションを再生します
ループを実行しています
ロボットを選択し[Envelope]にチェックを入れます
ループから抜けプログラムを終了しました
ルーチンとロボットプログラムにオリジナルの変数を作成します
Mainルーチンを選択し[新規変数を追加]をクリックすることでブール変数、整数、実数、または文字列を追加することができます
整数変数を追加します
名前をcounterに変更しデフォルトの値が0であることを 確認します
同じルーチン内にある限りルーチン変数を参照しWHILEステートメントの条件式として使用する ことができます
ロボットプログラムの他のルーチンでは 使用することができません
WHILEステートメントのコンディション に「counter < 3」と入力します
counterが3未満である限りループを実行します
counterの値を変更しない場合ループから抜けることができません
変数割り当てステートメントを追加し変数の値を変更します
ターゲットプロパティにcounter数式値にcounter+1と入力します
ルーチン変数を参照し現在の値を取得し値に1加算します
Mainメインルーチンを選択しcounterの値が0であることを確認しシミュレーションを再生します
ループが実行されボックスをピックアップするたびにcounterの値が増加します
counterの値が3になりWHILEステートメントの条件を満たさなくなるのでループを抜けメッセージを表示しシミュレーションを終了します
ロボットプログラムが終了した状態でシミュレーションを再生します
ロボットは動作していません
現状WHILEステートメントとルーチン変数はメインルーチンにありループを実行しています
Trueにループバックする場合ロボットがボックスを3つピックアップする必要がありますが
シミュレーションが停止状態になりプログラムは無限ループしていることが確認できます
シミュレーションを停止しMainルーチンを選択します
ロボットプログラムをループしていたためcounterが0にリセットされることはありません
counterが3になりWHILEステートメントから抜けますがロボットプログラムは前後にループし続けます
ループの下にcounterの値を設定する変数割り当てステートメントを追加し修正します
counterの値を0に戻します
シミュレーションを再生し動作を確認します
ループが正常に機能していることが確認できます
シミュレーションをリセットします
Mainルーチンに戻ります
Mainルーチン以外のサブルーチンに WHILEステートメントがある場合サブルーチンを呼び出すたびにルーチン変数が初期値にリセットされます
Mainルーチンをコピーし名前をPickPlaceBoxに変更します
ロボットプログラムでルーチンをコピーするとルーチン変数もコピーされます
PickPlaceBoxにはオリジナルの変数counterがあります
PickPlaceBoxからcounterの値を0に戻すステートメントを削除します
メインルーチンにあるWHILEステートメントを削除します
WHILEステートメントを削除すると配下にあるステートメントも削除されます
Mainルーチンに残っている全てのステートメントを削除しMainルーチンにPickPlaceBoxを呼び出すためにコールシーケンスステートメントを追加します
ロボットプログラムを実行することでPickPlaceBoxを呼び出します
PickPlaceBoxが呼び出されると変数counterが初期化され値は0になります
ループが実行されボックスをピックアンドプレイスするたびに変数counterの値が1ずつ増加しループを実行するための条件を満たさなくなると[出力]ウィンドウにメッセージを表示します
Mainルーチンに戻りロボットプログラムは再度ループします
シミュレーションを再生し動作を確認します
PickPlaceBoxを呼び出すたびにルーチン変数が初期値にリセットされるためループの最後にルーチン変数を0に戻すステートメントは必要ありません
PickPlaceBoxを選択し変数counterの値が0であることを確認しシミュレーションを再生します
ボックスをピックアンドプレイスするたびにcounterの値が1増加しますがロボットプログラムがループし値が0に戻ります
ロボットの[コンポーネントプロパティ]にある[Executor]の[ルーピング]にチェックが付いていない場合ロボットプログラムを一度だけ実行するため、Mainルーチンが実行しボックスをピックアンドプレイスし終了します
BOXを3つピックアンドプレイスし シミュレーションが停止しました
シミュレーションを再度再生してもロボットは動作しません
シミュレーションをリセットします
ステートメントの条件式を書くためにサポートが必要な場合[ヘルプ]タブに移動しヘルプファイルを開きます
ヘルプファイルのリファレンスガイドの中にある数式では条件式の記述に使用できる関数、グループ演算子の使用方法演算子の優先順位、変数の型変換、変数の型と演算子の関係値を渡す場合の単位の指定について説明しています
WHILEステートメントについてはロボットステートメントの継続条件にあり条件式の詳細について説明しています
条件式でロボットの入力ポートを参照する場合inハッシュタグと入力し名前を参照することで使用できます
シミュレーション再生中ロボットプログラムを繰り返し実行する方法についての説明は以上となります
ご視聴いただきありがとうございました

=================================================================================

ロボットプログラムを読み取ろう(1/3)

ロボットプログラムをパイソンスクリプト（Python）を用いて読み取る方法（ロボットエグゼキュータ、メインルーチンのステートメント）
（関連動画：ロボットをPythonで制御しよう(1/3)。ロボットをPythonで制御しよう(2/3)、ロボットをPythonで制御しよう(3/3)）
https://youtu.be/YqZAd-8LGjc
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_140_p1.zip

ロボットプログラムを読み取る方法を説明します。
パイソンスクリプトを使用して、ロボットプログラムやルーチン、ルーチン内のステートメントを読み取ります。
パート1では、メインルーチンのステートメントを読み取ります。
[Python Robotics - 1 - Read a Robot Program_Part1_Before.vcmx]をダウンロードし、開きます。
3Dワールドにロボット、ブロック、パレットが配置されています。
シミュレーションを実行すると、ロボットがブロックを持ち上げ、パレットに置きます。
パレットに置いたブロックを再度持ち上げ、床にブロックを置きます。
ロボットプログラムにループ処理がされているため、同じ動作を2回繰り返した後、シミュレーションが一時停止します。
シミュレーションをリセットします。
ロボットプログラムを確認します。
[プログラム]タブを開きます。
[マニピュレーション]-[ジョグ]が選択された状態で、ロボットを選択します。
[プログラムエディタ]ウィンドウの[サブプログラム]を確認すると、メインルーチンと4つのサブルーチンがあります。
ロボットプログラムを読み取るパイソンスクリプトを作成します。
[モデリング]タブを開きます。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を作成します。
3行目以降を削除します。
comp = getComponent()と記述し、Pythonスクリプトを設定しているコンポーネントを取得します。
robotExecutor = comp.findBehavioursByTypeと記述し、コンポーネント内の指定したタイプのビヘイビアを取得します。
[コンポーネントグラフ]ウィンドウのビヘイビアを確認すると、Executorがあることがわかります。
今回は、ロボットのExecutorを取得するため、VC_ROBOTEXECUTORと記述します。
ロボットエグゼキュータを使用すると、ロボットプログラムの読み出しや、書き込み、実行ができます。
findBehaviourByTypeは、対象のビヘイビアをリストとして取得するため、0と記述し、0番目のエグゼキュータのみ取得します。
print robotExecutorと記述し、ロボットエグゼキュータを[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、ロボットエグゼキュータの情報が表示されています。
ロボットエグゼキュータを取得したことが確認できたため、print関数を削除します。
robotProgram = robotExecutor.Programと記述し、ロボットプログラムの情報を取得します。
print robotProgramと記述し、ロボットプログラムを[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、ロボットプログラムの情報が表示されています。
print関数を削除します。
ロボットプログラムのルーチンを取得します。
[プログラム]タブを開きます。
[サブプログラム]のメインルーチンを取得します。
mainRoutine = robotProgram.MainRoutineと記述し、メインルーチンの情報を取得します。
print mainRoutineと記述し、メインルーチンを[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、メインルーチンの情報が表示されています。
print関数を削除します。
ロボットプログラムのサブルーチンを取得します。
subroutines = robotProgram.Routinesと記述し、サブルーチンの情報を取得します。
print subroutinesと記述し、サブルーチンを[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、サブルーチンの情報が4つ表示されています。
サブルーチンは4つあるため、サブルーチンを取得できたことがわかります。
print関数を削除します。
[サブプログラム]のメインルーチンを選択します。
[ルーチンプロパティ]ウィンドウを開きます。
[変数]を確認すると、デフォルトでcountという名称の変数が1つあることがわかります。
パイソンスクリプトで変数の情報を取得します。
for property in mainRoutine.Properties:と記述し、メインルーチンのプロパティをpropertyという変数に代入します。
print property.Nameと記述し、名称を[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、countという名称の変数があることがわかります。
変数の情報を取得できたため、for文の記述を削除します。
メインルーチンのステートメントを取得します。
statements = mainRoutine.Statementsと記述し、メインルーチンのステートメントを取得します。
print statementsと記述し、ステートメントを[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、2つのステートメントが表示されています。
[プログラムエディタ]ウィンドウのメインルーチンには、7つのステートメントがあるため、全てのステートメントが取得できていないことがわかります。
ロボットプログラムのルーチンには、スコープがあります。
スコープとは、プログラムの影響範囲のことです。
メインルーチンのスコープは、Main内の7つのステートメントです。
PickCubeFromFloorのサブルーチンのスコープは、PickCubeFromFloor内の4つのステートメントです。
メインルーチンのステートメントを確認すると、While文の中に5つのステートメントが入っています。
ステートメントも独自のスコープを持つことができ、while文はスコープを持っています。
mainRoutine.Statementsの記述では、Assign countとWhile countの2つのステートメントが取得でき、while内のステートメントは取得できていないということがわかります。
While文の中のステートメントを取得します。
print関数を削除します。
for statement in statements:と記述し、メインルーチンのステートメントをstatementという変数に代入します。
if statement.Scopes:と記述し、メインルーチンにスコープがあるかどうか確認します。
print statement.Scopesと記述し、スコープを持つステートメントを[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、メインルーチンにスコープが1つあることがわかります。
print関数を削除します。
スコープ内のステートメントを取得します。
for scope in statement.Scopes:と記述し、スコープ内のステートメントをscopeという変数に代入します。
print scope.Statementsと記述し、スコープ内のステートメントを[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、5つのステートメントが表示されています。
While文の中には、5つのステートメントがあるため、スコープ内のステートメントを取得できたことがわかります。
パート1の説明は以上となりますが、ファイルを保存する場合は、OnRun関数やOnStart関数を作成し、4行目以下のソースコードを入れてください。
関数を使用せずにファイルを保存して再度開くと、コードが実行されますが、コンポーネントの全ての情報を即座に読み取ることができずエラーが発生します。
そのため、OnRun関数やOnStart関数を使用して、ファイルを読み込む際にコードをすぐに実行しないことで、エラーを回避できます。
一括でインデントを入れるには、インデントを入れたい行を選択し、tabキーを押します。
ロボットプログラムのメインルーチンのステートメントを読み取る方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットプログラムを読み取ろう(2/3)

ロボットプログラムをパイソンスクリプト（Python）を用いて読み取る方法（全てのステートメント）
（関連動画：ロボットをPythonで制御しよう(1/3)。ロボットをPythonで制御しよう(2/3)、ロボットをPythonで制御しよう(3/3)）
https://youtu.be/vIB835dEeMw
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_140_p2.zip

ロボットプログラムを読み取る方法を説明します。
パート1では、ロボットプログラムのメインルーチンのステートメントを読み取りました。
パート2では、ロボットプログラム内の全てのステートメントを読み取ります。
パート1で使用したファイル、もしくは、[Python Robotics - 1 - Read a Robot Program_Part1_After.vcmx]をダウンロードし、開きます。
ロボットを選択します。
[モデリング]タブを開きます。
[コンポーネントグラフ]ウィンドウの[RV-13FL]-[PythonScript]を開きます。
[プログラム]タブを開きます。
def OnRun関数を削除し、関数内のソースコードのインデントを1つ左にします。
一括でインデントを1つ左にするには、インデントを削除したい行を選択し、shiftキーを押しながら、tabキーを押します。
メインルーチンの7つ全てのステートメントを一度に取得します。
for文を削除します。
def getAllStatementsInRoutine():と記述し、getAllStatementsInRoutineの関数を作成します。
第一引数は、scopeにします。
第二引数は、ステートメントのリストを収集するため、statementsにし、デフォルトの値をNoneにします。
if not statements:statements = []と記述し、ステートメントがNoneもしくは空の場合、ステートメントを収集するための空のリストを作成します。
ルーチンのスコープを取得します。
for statement in scope.Statements:と記述し、スコープのステートメントをstatementという変数に代入します。
statements.append(statement)と記述し、ステートメントをリストに追加します。
ルーチン内のスコープを取得します。
if statement.Scopes:と記述し、ルーチン内のステートメントがスコープを持っているかどうか確認します。
for scope in statement.Scopes:と記述し、ステートメントが持っている各スコープをscopeという変数に代入します。
例えば、メインルーチンの場合、While文のみスコープを持っているため、While文のステートメントをscopeに代入します。
getAllStatementsInRoutine(scope, statements)と記述し、スコープをgetAllStatementsInRoutine関数に再帰的に渡します。
これにより、スコープ内のステートメントもstatementsリストに追加されます。
ステートメントのリストが渡されるため、関数のstatementsはNoneや空にならず、新しい空のメソッドを作成することなく、既存のリストを使用することができます。
return statementsと記述し、スコープ内のすべてのステートメントを含むリストを返します。
print len()と記述し、リストの長さ、つまり、ステートメントの数を表示します。
メインルーチンスコープ内のステートメントの数を表示するため、getAllStatementsInRoutine(mainRoutine)と記述します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、7が表示されています。
メインルーチンには7つのステートメントがあるため、全てのステートメントを取得できたことがわかります。
サブルーチンのステートメントを取得します。
11行目のsubroutinesを使用します。
mainRoutineを削除します。
subroutines[0]と記述し、0番目のサブルーチンのステートメントを取得します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、4が表示されています。
PickCubeFromFloorには4つのステートメントがあるため、ステートメントを取得できたことがわかります。
print関数を削除します。
ロボットプログラム内の全てのステートメントを取得します。
def getAllStatementsInRobotProgram()と記述し、getAllStatementsInRobotProgramの関数を作成します。
引数をprogramにします。
statements = getAllStatementsInRoutine(program.MainRoutine)と記述し、メインルーチンに対して、getAllStatementsInRoutineの関数を呼び出します。
return statementsと記述し、ステートメントのリストを返します。
print getAllStatementsInRobotProgram(robotProgram)と記述し、ロボットプログラムのステートメントを[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、7つのステートメントが表示されています。
lenと記述し、ステートメントの数を表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、7が表示されています。
メインルーチンには7つのステートメントがありますが、呼び出している4つのサブルーチン内のステートメントが取得できていないことがわかります。
パイソンスクリプトを修正し、ロボットプログラム内の全てのステートメントを取得します。
メインルーチンのCall PickCubeFromFloorを選択します。
[ステートメントプロパティ]ウィンドウを確認すると、呼び出しているルーチンが表示されています。
各ステートメントにプロパティがあるかを確認し、ステートメントの関数を呼び出すことで、サブルーチン内のステートメントを取得します。
subroutine = statement.getProperty("Routine")と記述し、ステートメントプロパティのRoutineを取得します。
if subroutine:getAllStatementsInRoutine(subroutine.Value)と記述し、プロパティを持っている場合、getAllStatementsInRoutine関数に再帰的に渡します。
これにより、サブルーチン内のステートメントもstatementsリストに追加されます。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、23が表示されています。
メインルーチンには、7つのステートメントがあり、各サブルーチンには、4つのステートメントがあるため、23個すべてのステートメントが表示されたことがわかります。
サブルーチン内のステートメントは、実際にはgetAllStatementsInRoutine関数で呼び出しているルーチン内には存在しません。
今回は、メインルーチンに対して処理を行っていますが、メインルーチン内にサブルーチンのステートメントはありません。
メインルーチンでサブルーチンを呼び出していない場合、サブルーチン内のステートメントを取得することができません。
そのため、getAllStatementsInRobotProgram関数で、サブルーチン内のステートメントを取得します。
26～28行目を切り取ります。
getAllStatementsInRobotProgram関数にfor statement in statements:と記述し、メインルーチンのステートメントをstatementという変数に代入します。
for文に切り取ったソースコードを貼り付けます。
ステートメントにルーチンプロパティがある場合、プロパティの値とステートメントリストを使用して、ルーチンメソッド内の全てのステートメントを取得します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、23が表示されています。
全てのステートメントを取得できたことがわかります。
getAllStatementsInRobotProgaram関数では、呼び出されたサブルーチンを含むメインルーチンで実行されるステートメントのリストを返します。
今回は行いませんが、引数を追加し、呼び出していない未使用のサブルーチンを取得することもできます。
メインルーチンにステートメントを追加します。
サブプログラムのMainを選択します。
[IFステートメント]を追加します。
デフォルトでは、ThenとElseで2つの条件に分岐できます。
Assin count = 0をWhile文の後ろに移動します。
[If True:]を選択し、[ステートメントプロパティ]ウィンドウの[コンディション]で条件を設定します。
[コンディション]にcount==2と入力します。
Thenで、カウントが2のとき、[出力]ウィンドウに文字を表示する処理を記述します。
Thenを選択し、[プリントステートメント]を追加します。
[ステートメントプロパティ]の[メッセージ]にRobot picked and placed a cubeと記述し、ロボットがブロックを持ち上げ、置いたことを表示します。
Elseで、カウントが2以外のとき、ロボットプログラムにコメントを残します。
Elseを選択し、[コメントステートメント]を追加します。
IFステートメントを追加することで、スコープを持つステートメントが1つ追加されたことがわかります。
スコープ内にはステートメントが2つあり、合計で3つのステートメントが追加されています。
print len(getAllStatementsInRoutine(mainRoutine))と記述し、メインルーチン内のステートメントの数を[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、10と26が表示されています。
メインルーチンには10個のステートメント、全てのルーチンには26個のステートメントがあるため、ステートメントの数が正しく表示されたことがわかります。
print関数に#を付けて、コメントアウトします。
パート2の説明は以上となりますが、ファイルを保存する場合は、OnRun関数やOnStart関数を作成し、4行目以下のソースコードを入れてください。
一括でインデントを入れるには、インデントを入れたい行を選択し、tabキーを押します。
ロボットプログラム内の全てのステートメントを読み取る方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットプログラムを読み取ろう(3/3)

ロボットプログラムをパイソンスクリプト（Python）を用いて読み取る方法（モーションステートメント、ソースコードのpyファイル保存）
（関連動画：ロボットをPythonで制御しよう(1/3)。ロボットをPythonで制御しよう(2/3)、ロボットをPythonで制御しよう(3/3)）
https://youtu.be/hk2yfT-7Qu4
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_140_p3.zip

ロボットプログラムを読み取る方法を説明します。
パート2では、ロボットプログラム内の全てのステートメントを読み取りました。
パート3では、位置に関するステートメントを取得し、pythonファイルを作成します。
[Python Robotics - 1 - Read a Robot Program_Part2_After.vcmx]をダウンロードし、開きます。
ロボットを選択します。
[モデリング]タブを開きます。
[コンポーネントグラフ]ウィンドウの[RV-13FL]-[PythonScript]を開きます。
[プログラム]タブを開きます。
def OnRun関数を削除し、関数内のソースコードのインデントを1つ左にします。
一括でインデントを1つ左にするには、インデントを削除したい行を選択し、shiftキーを押しながら、tabキーを押します。
位置に関するステートメントを取得します。
positions = []と記述し、位置に関するステートメントを収集するリストを作成します。
メインルーチンを確認すると、位置に関するステートメントがないため、サブルーチンから取得します。
for statement in subroutines.Statements:と記述し、サブルーチン内のステートメントをstatementという変数に代入します。
print statementと記述し、ステートメントを[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、サブルーチンのようなリストに対しては、Statementの属性が使用できないため、エラーが表示されています。
subroutinesに0を追加し、0番目のサブルーチンのステートメントを取得します。
[出力]ウィンドウを右クリックし、削除します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、PickCubeFromFloorのステートメントが表示されています。
[サブプログラム]のPickCubeFromFloorには、3つの位置に関するステートメントと1つのバイナリ出力ステートメントがあります。
[出力]ウィンドウには、3つのモーションステートメントと1つの通常のステートメントが表示されています。
vcMotionStatementが位置に関するステートメントということがわかります。
vcMotionStatementはvcPositionStatementを継承しているため、Positionというプロパティを使用することで、ステートメント内の位置のリストを取得できます。
print statement.Positionsと記述すると、位置情報を持たないバイナリ出力ステートメントが表示できず、エラーで処理が止まります。
try-except文を使用し、例外処理をすることで、エラーで処理が止まらないようにします。
try:print statement.Positionsと記述し、[出力]ウィンドウに位置に関するステートメントを表示します。
except:continueと記述し、位置情報を持たないステートメントがあった場合、処理をせず、次の処理に進みます。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、vcPositionFrameが3つ表示されています。
[サブプログラム]のPickCubeFromFloorには、3つの位置に関するステートメントがあるため、0番目のサブルーチン内のすべての位置に関するステートメントが取得できたことがわかります。
指定したルーチン内の全てのステートメントを取得します。
positions以降をコメントアウトします。
コメントアウトするには、アポストロフィーをコメントアウトしたいソースコードの最初と最後に3つずつ付けます。
def getAllPositionsInRoutine()と記述し、getAllPositionsInRoutineの関数を作成します。
引数をscopeにします。
statements = getAllStatementsInRoutine(scope)と記述し、getAllStatementsInRoutineの関数を呼び出します。
positions = []と記述し、位置に関するステートメントを収集するための空のリストを作成します。
for statement in statements:と記述し、ルーチン内のステートメントをstatementという変数に代入します。
try:for position in statement.Positions:と記述し、位置に関するステートメントをpositionという変数に代入します。
positions.append(position)と記述し、位置に関するステートメントをリストに追加します。
except:passと記述し、位置情報を持たないステートメントがあった場合、処理をせず、次の処理に進みます。
return positionsと記述し、位置に関するステートメントのリストを返します。
print getAllPositionsInRoutine(mainRoutine)と記述し、メインルーチンのステートメントを[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、メインルーチンには位置に関するステートメントがないため、空のリストが表示されています。
print関数をコメントアウトします。
サブルーチンの全ての位置に関するステートメントを取得します。
for subroutine in subroutines:と記述し、サブルーチンをsubroutineという変数に代入します。
print getAllPositionsInRoutine(subroutine)と記述し、サブルーチン内の全ての位置に関するステートメントを[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、12個のステートメントが表示されています。
[サブプログラム]の4つのサブルーチンを選択すると、各サブルーチンには、3つの位置に関するステートメントがあるため、12個すべてのステートメントが表示されたことがわかります。
print関数とfor文を削除します。
ロボットプログラム内の全ての位置に関するステートメントを取得します。
def getAllPositionsInRobotProgramと記述し、getAllPositionsInRobotProgramの関数を作成します。
引数をprogramにします。
positions = []と記述し、位置に関するステートメントを収集するリストを作成します。
メインルーチン内の位置に関するステートメントを取得します。
positions = getAllPositionsInRoutine(program.MainRoutine)と記述し、メインルーチン内に対して、getAllPositionsInRoutine関数を呼び出します。
サブルーチン内の位置に関するステートメントを取得します。
for subroutine in program.Routines:と記述し、プログラム内のサブルーチンをsubroutineという変数に代入します。
positionsInSubroutine = getAllPositionsInRoutine(subroutine)と記述し、サブルーチン内でgetAllPositionsInRoutineの関数を呼び出します。
取得したサブルーチン内の位置に関するステートメントをpositionsのリストに追加します。
for position in positionsInSubroutine:と記述し、サブルーチン内の位置に関するステートメントをpositionという変数に代入します。
positions.append(position)と記述し、リストにステートメントを追加します。
return positionsと記述し、ステートメントのリストを返します。
print len(getAllPositionsInRobotProgram(robotProgram))と記述し、ロボットプログラム内の全てのステートメントの数を[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、12が表示されています。
メインルーチンに位置に関するステートメントがなく、各サブルーチンに3つのステートメントがあるため、12個すべてのステートメントが表示されたことがわかります。
print関数をコメントアウトします。
パイソンスクリプト内のソースコードをファイルとして保存し、Geminiにインポートできるようにします。
メモ帳を開きます。
全ての関数をコピーします。
メモ帳に貼り付けます。
[ファイル]-[名前を付けて保存]をクリックします。
[ドキュメント]-[MITSUBISHI]-[Gemini]-[1.46]-[My Commands]に保存します。
フォルダの[1.46]は[Gemini]のバージョンによって異なります。
今回は、GeminiのVer.1.46を使用するため、[1.46]に保存します。
ファイル名を[ReadRobotProgram]、拡張子をPythonファイルの[.py]にし、保存します。
Geminiのパイソンスクリプトを開き、全ての関数を削除します。
statementsは不要なため、削除します。
from ReadRobotProgram import *と記述し、作成したPythonファイルを読み込みます。
print getAllStatementsInRoutine(mainRoutine)と記述し、[出力]ウィンドウにメインルーチンのステートメントを表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、メインルーチンのステートメントが表示されています。
print関数にlenを追加し、ステートメントの長さを表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、10が表示されています。
Pythonファイルを読み込みできていることがわかります。
My Commandsフォルダを開くと、pycファイルが生成されていることがわかります。
pycファイルはコンパイル時に自動で作成され、次回以降のコンパイルが速くなります。
不要な場合は、削除しても問題ありません。
pycファイルを削除します。
Geminiを開きます。
print関数で呼び出している関数をgetAllStatementsInRobotProgram(robotProgram)に変更します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、26が表示されます。
pycファイルを削除しても、動作することがわかります。
パート3の説明は以上となりますが、ファイルを保存する場合は、OnRun関数やOnStart関数を作成し、5行目以下のソースコードを入れてください。
一括でインデントを入れるには、インデントを入れたい行を選択し、tabキーを押します。
また、「ReadRobotProgram.py」を「My Commands」に保存していない状態でファイルを開くと、PythonScriptの「from ReadRobotProgram import*」が「ReadRobotProgram.py」を見つけられず、エラーが発生します。
「ReadRobotProgram.py」を「My Commands」に保存してからファイルを開き直してください。
位置に関するステートメントを取得し、pythonファイルを作成する方法は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットプログラム実行中の干渉を自動で解決しよう

Gemini 1.48以降の機能です。
ロボットプログラムの干渉を回避する経路を生成する方法（経由パスを解決する）
https://youtu.be/ya1EJoMt-tE
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_127.zip

本動画では、ロボットプログラム実行中、ロボットが他のコンポーネントと干渉する時に、その干渉を自動で解決する方法を説明します。
"経由パスの解決"機能を使用します。
この機能はバージョン1.48以降で使用できます。
初めに、「ロボットプログラム実行中の干渉を自動で解決しよう.vcmx」を開きます。
シミュレーションを再生します。ロボットプログラムが実行され、ロボットが動きます。
この時、ロボットが台座を貫通するように移動する時があります。
[プログラム]タブに移動して、ロボットプログラムの各ロボットステートメントを確認します。
移動先の各フレームの位置は問題ありません。
つまり、各ロボットステートメントが実行され、ロボットが移動する時に干渉が起きていることになります。
干渉が発生しているロボットステートメントを特定し、干渉が起こらないようにします。
干渉を検出したい場合、[プログラム]タブ-[干渉検出]-[ディテクターを有効にする]にチェックを付けます。
これで、干渉が発生した箇所を可視化できるようになります。
次に、干渉が発生した時に、シミュレーションを停止するようにします。
[プログラム]タブ-[干渉検出]-[干渉の停止]にチェックを付けます。
これで、干渉が発生した時に、シミュレーションが停止するようになりました。
シミュレーションを再生します。
P2へ移動する各軸補間ステートメントで干渉が発生していることが確認できました。
次に、この干渉を発生しないように修正します。
ロボットの動きを1つ1つ手作業で設定して修正する方法もありますが、今回は、"経由パスを解決する"機能を使用して、修正します。
"経由パスを解決する"機能は、選択しているステートメントの1つ前の位置から選択したステートメントへ移動する時の間で干渉が起こる場合、干渉が起こらないように移動するステートメントを、その2つのステートメントの間に自動的に設定する機能です。
"PTP P2 ~"を右クリックし、"経由パスの解決設定"をクリックします。
すると、[経由パスの解決]ウィンドウが表示されます。
このウィンドウでは、"経由パスを解決する"機能についての設定や、選択中のステートメントに"経由パスを解決する"機能を適用することができます。
[経由パスの解決]ウィンドウの項目について説明します。
"使用方法"には、この機能を実行するための手順が記載されています。
"プリセット"は、設定値をプリセットとして保存することができます。
プリセットは"プリセットを追加"ボタンから作成することができます。
また、専用のファイル形式でエクスポートしたり、ファイルをインポートしたりすることもできます。
プリセットは、"パラメータをプリセットから読み込む"ボタンを押すことで使用できます。
"全般"は、この機能の設定を変更することができます。
プリセットには、ここで設定した値がすべて記録されます。
各項目について説明します。
"解決時間"は、この機能で干渉を解決するためにかけることができる時間の最大値の設定です。
"スムージング時間"は、動作をより滑らかにするためにかけることができる時間の最大値の設定です。
"解析時間"と"スムージング時間"はどちらも、各工程にかけることのできる最大値の設定であるため、設定した時間よりも早く解決できることや、時間内に解決できないこともあります。
"補間ステップ"は、ロボットの動作を補間するときの距離的な補間間隔の設定です。
ロボットプログラムでは各軸補間ステートメントや直線補間ステートメントによってロボットの動作を制御しますが、そこで決まっているのは、目的地と移動方法、移動時間や速度のみです。
ステートメント間でのロボットの動きは計算によって補間されています。
この補間を実行する頻度を"補間ステップ"で設定することができます。
値が小さいほど補間が頻繁に行われ、より精密な解析になります。
"常にパスを追加する"は、チェックを入れると、必要がない場合でも経由パスが必ず作成されるようになります。
"PTP速度"、"LIN速度"、"近距離速度"では、この機能で追加するステートメントの速度設定を事前に行うことができます。
"PTPのみ"は、チェックを入れると"経由パスを解決する"機能でステートメントを追加する時に、各軸補間ステートメントだけを使用するようになります。
"全般"の設定項目の説明は、以上になります。
実際に"経由パスを解決する"機能を使って、干渉を解決します。
"PTP P2~"を選択した状態で、"解決"ボタンをクリックします。
バックグラウンドで解析が行われています。
しばらくすると、"経由パスは正常に解決されました"と表示され、ロボットプログラムにステートメントが追加されます。
リセットをクリックして、ロボットを初期位置に戻します。
シミュレーションを再生します。
ロボットプログラムに、干渉を回避するように動くロボットステートメントが設定されたことが確認できます。
同様の手順で、残りの干渉が検出されたロボットステートメントも修正します。
"PTP P3～"を右クリックします。
"経由パスを解決する"は、[経由パスの解決]ウィンドウで"解決"をクリックした時と同じ動作をします。
"経由パスを解決する"をクリックします。
ステートメントが追加されたら、リセットをクリックして、ロボットを初期位置に戻します。
シミュレーションを再生します。
"PTP P3 ～"の干渉が解決できました。
最後に、"PTP P5～"を右クリックし、"経由パスを解決する"をクリックします。
干渉する箇所が多いため、他のステートメントよりも解決に時間がかかります。
ステートメントが追加されたら、リセットをクリックして、ロボットを初期位置に戻します。
シミュレーションを再生します。
"経由パスを解決機能"で、すべての干渉が解決できました。
以上で、「ロボットプログラム実行中の干渉を自動で解決しよう」を終わります。
ご視聴ありがとうございました。

=================================================================================

ロボットをPythonで制御して製品を整列してみよう(1/2)

ロボットをパイソンスクリプト（Python）で制御して、コンベア上の製品を持ち上げる方法（pickMovingPart）
（関連動画：ロボットプログラムをPythonで記述してみよう、ロボットをPythonで制御しよう(2/3)）
https://youtu.be/V4-0uEP2H7Q
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_144_p1.zip

ロボットで製品をピッキングして整列する方法を説明します。
Pythonスクリプトでロボットを制御し、コンベア上のワークを持ち上げた後、ワークの向きを整列してコンベア上に戻します。
パート1では、コンベア上のワークをピックアップする方法を説明します。
関連動画として、「ロボットプログラムをPythonで記述してみよう」があります。是非ご覧ください。
[Picker Robot_part1_before.vcmx]をダウンロードし、開きます。
3Dワールドにパラレルリンクロボットとコンベアが配置されています。
シミュレーションを実行すると、コンベア上にワークが流れます。
シミュレーションをリセットします。
設定を確認します。
[プログラム]タブを開きます。
ロボットを選択します。
[接続]-[シグナル]を選択します。
コンベアの[SensorBooleanSignal]とロボットの100が接続されています。
ワークがコンベア上のセンサーを通ったときに、ロボットの100にシグナルを入力します。
[マニピュレーション]-[ジョグ]が選択された状態でロボットを確認すると、ピンク色の丸があります。
ピンク色の丸は、ロボットの移動先を決める基準点です。
ロボットについたVacuum Gripperの先端にピンク色の丸を移動し、Vacuum Gripperの先端でワークをピックアップするよう設定します。
[ジョグ]ウィンドウの[ツール]で、TOOL_DATA[0]を選択します。
ピンク色の丸がVacuum Gripperの先端にあるTOOL_DATA[0]の位置に移動していることがわかります。
動作などを設定する前に、リセットボタンを押してしまうと、[ツール]が[Null]に戻るため、[TOOL_DATA[0]]を選択した状態を保存します。
シミュレーションバーの歯車のアイコンをクリックします。
[状態の保存]をクリックし、[ツール]に[TOOL_DATA[0]]を選択した状態を保持します。
Pythonスクリプトでロボットの動作を設定します。
[モデリング]タブを開きます。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を追加します。
今回は使用しないため、OnSignal関数は削除します。
OnRun内のpassを削除します。
from vcHelpers.Robot2 import *と記述し、ロボットのライブラリを呼び出します。
ロボットのライブラリには、ロボットを制御するときに便利なメソッドが含まれています。
robot = getRobot()と記述し、ロボットの情報を取得します。
print robotと記述し、ロボットの情報を[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
シミュレーションを実行し、リセットします。
[出力]ウィンドウを確認すると、ロボットの情報が表示されています。
ロボットの情報を取得したことが確認できたため、print関数を削除します。
ワークがセンサーを通過したときの動作を設定します。
while robot.SignalMapIn.input(100) != True:と記述し、ロボットの入力シグナルの100がTrueになるか、チェックを続けます。
delay(0.1)と記述し、Trueになるまで0.1秒ごとにチェックします。
print "part is ready to be picked up"と記述し、センサーがワークを検知したとき、ピックアップの準備ができたことを[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ワークがセンサーを通過したとき、[出力]ウィンドウにピックアップの準備ができたというメッセージが表示されます。
シミュレーションをリセットします。
センサーがワークを検知していることが確認できたため、print関数を削除します。
コンベア上でどのワークをピッキングするか指定します。
picked = []と記述し、ピックアップ済みのワークのリストを作成します。
app = getApplication()と記述し、アプリケーション情報を取得します。
conveyor = app.findComponent("Sensor Conveyor")と記述し、Sensor Conveyorの情報を取得します。
print conveyor.ChildComponentsと記述し、Sensor Conveyorの全ての子コンポーネントを[出力]ウィンドウに表示します。
コンベア上のワークなど、コンベアに関連する全てのコンポーネントを表示するために使用します。
コンパイルボタンをクリックします。
[出力]ウィンドウを右クリックし、メッセージをクリアします。
シミュレーションを実行します。
ワークがセンサーを通過したとき、[出力]ウィンドウにコンベア上の2つのワークの情報が表示されます。
シミュレーションをリセットします。
ロボットがワークを持ち上げる動作を設定します。
13行目のprintを削除した後、parts =と記述し、ワークの情報をpartsという変数にリストとして代入します。
コンベヤ上のワークから、ピックアップしていないワークのみ抽出します。
for part in parts:と記述し、parts変数リストの各ワークをpartという変数に代入します。
if part in picked:と記述し、ワークがピックアップ済みのワークのリストに存在するか確認します。
parts.remove(part)と記述し、ワークがすでにピックアップされている場合、ワークをparts変数のリストから削除します。
コンベアに入った順でワークはparts変数のリストの末尾に代入されるため、part = parts.pop()と記述し、リストの末尾にあるワークをpart変数に代入します。
robot.pickMovingPart(part)と記述し、ピックアップ済みではないワークの内、コンベアに入った順が最も古いワークをピックアップします。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ロボットが先頭のワークをピックアップします。
シミュレーションをリセットします。
コンベア上のワークをピックアップする方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットをPythonで制御して製品を整列してみよう(2/2)

ロボットをパイソンスクリプト（Python）で制御して、製品の向きを変えてコンベア上に置く方法（place）
（関連動画：ロボットプログラムをPythonで記述してみよう、ロボットをPythonで制御しよう(2/3)）
https://youtu.be/NIVLA1NbSgw
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_144_p2.zip

ロボットで製品をピッキングして整列する方法を説明します。
パート1では、コンベア上のワークをピックアップする方法を説明しました。
パート2では、コンベア上のワークをピックアップした後、コンベアに戻す方法を説明します。
[Picker Robot_part1_after.vcmx]をダウンロードし、開きます。
ロボットを選択します。
[モデリング]タブを開きます。
[コンポーネントグラフ]ウィンドウの[Generic Delta Robot]-[ビヘイビア]-[PythonScript]を開きます。
ピックアップしたワークをコンベア上に戻します。
robot.place(conveyor)と記述し、ワークをコンベアに置きます。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ロボットが先頭のワークをピックアップした後、コンベア上に戻します。
シミュレーションを一時停止します。
コンベア上に戻したワークが、コンベアの幅の中央に整列して配置されていることがわかります。
シミュレーションをリセットします。
シミュレーションを再度実行し、ワークを置いた後、一時停止します。
ワークが先ほどと同様の位置に置かれています。
デフォルトで、ワークの向きや位置が整列されていることがわかります。
今回は説明しませんが、ワークの向きを変更することもできます。
詳細は、ヘルプの「vcHelpers.Robot2」のメソッド「place」を参照してください。
ワークをコンベアの中心より先でピックアップし、コンベアの中心に戻して置いているため、次のワークとの距離が近くなっています。
ワークをピックアップした位置と同じ位置にワークを置くことで、次のワークとの距離を保てるようにします。
ワークをピックアップした位置を取得します。
part = robot.GraspContainer.Componentsと記述し、ロボットが掴んでいるワークを取得します。
ロボットは1つのワークのみ掴んでいるため、リストの0番目を取得します。
pos = part.WorldPositionMatrixと記述し、ワークを垂直に持ち上げた後の、ワークのワールド座標を取得します。
ワールド座標系は、XYZの3つの座標を取得するため、.Pと記述します。
コンベアの中心座標を取得します。
a = conveyor.PositionMatrixと記述し、コンベアの原点のワールド座標を取得します。
b = conveyor.BoundCenterと記述し、コンベアの原点から中心までのベクトルを取得します。
a.translateRelと記述し、コンベアの原点の位置を基準にして、指定した位置まで移動します。
コンベアの上面の中心まで移動するため、b.X、b.Y、b.Z*2と記述します。
ロボットをどれだけ移動するかオフセット値を計算します。
offsetX = pos.X - a.P.Xと記述し、ワークのX座標からコンベアの中心のX座標を引いたものをX座標のオフセット値とします。
20行目を切り取り、最終行にペーストします。
ロボットの位置からどれだけ移動するかを指定するため、Tx=offsetXと記述し、X座標のオフセット値を指定します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ロボットが先頭のワークをピックアップした後、ピックアップした位置と同じ位置に戻します。
シミュレーションをリセットします。
ワークを掴んだ位置のX座標、コンベアにワークを置くデフォルト位置のX座標、オフセットのX座標を知りたい場合は、print関数を使用して確認できます。
print pos.X、print a.P.X、print offsetXと記述し、それぞれのX座標を[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ロボットが先頭のワークをピックアップした後、一時停止します。
[出力]ウィンドウを確認すると、X座標の数値が表示されています。
pos.Xは848.25mmです。
ワークをクリックし、[フィーチャプロパティ]ウィンドウを確認すると、X座標に848.25と表示されています。
ロボットがワークを掴んだときのX座標が取得できていることがわかります。
a.P.Xは750.0mmです。
コンベアにワークを置くデフォルト位置のX座標が取得されています。
offsetXは、848.25-750.0=98.25mmであることがわかります。
シミュレーションをリセットします。
X座標の数値が確認できたため、print関数を削除します。
コンベア上の全てのワークを順番にピックアップするように設定します。
picked.append(part)と記述し、ピックアップしたワークをリストに追加します。
コンベア上から流れて存在しなくなったワークは処理が不要なため、コンベア上に残っているワークのみpickedのリストに残します。
picked = filterと記述し、指定した条件に合う要素を抽出します。
ワークを置いた後、コンベア上に残っているワークをpickedのリストに追加するため、lambda x: x in conveyor.ChildComponents, pickedと記述します。
while app.Simulation.IsRunning == True:と記述し、シミュレーション実行している間、ループ処理します。
アプリケーション情報とSensor Conveyorの情報の取得は一度で良いため、ループ処理の前に移動します。
インデントを入れるため、12行目以下の行を選択し、tabキーを押します。
全体の処理を整理するため、コメントを入れます。
まず初めに、ワークがセンサーに到着するまでの動作を設定しているため、#part reached sensorと記述します。
次に、コンベア内のワークを取得するため、#get partsと記述します。
次に、ワークをピックアップし、pickedのリストに追加するため、#picked part and add to picked listと記述します。
その後、部品をコンベアに戻すため、#place part back on conveyorと記述します。
コンベヤ上のワークから、ピックアップしていないワークのみ抽出するソースコードをfilter関数を使用して簡素化します。
parts = filterと記述し、指定した条件に合う要素を抽出します。
pickedのリストに入っていないワークのみ抽出するため、(lambda x: x not in picked, conveyor.ChildComponents)と記述します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ロボットがワークをピックアップした後、ピックアップした位置と同じ位置に戻します。
全てのワークに対して処理が実行されていることがわかります。
コンベア上のワークをピックアップした後、コンベアに戻す方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

ロボットを置き換えてみよう

ティーチングしたロボットを別の機種に置き換える方法
https://youtu.be/x6cgOpxVl_g
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_020.zip

3Dワールドでロボットを交換する方法について説明します。
コンベアからコンポーネントをピックアップし、隣のコンベアに搬送するロボットを交換します。
eカタログから交換したいロボットを選択します。
eカタログの中の[タイプ別モデル]を展開し、[Robots]をクリックします。
eカタログに登録されている、すべてのロボットが表示されます。
eカタログには、1000種類以上のロボットが登録されています。
現在配置されているロボットは、三菱電機製のロボットです。
[Robots]を展開すると、様々なロボットコンポーネントがメーカー別に表示されています。
メーカー名が見やすいように、eカタログのコレクションウィンドウを、ドラッグで大きくします。
その中から[Mitsubishi Electric]をクリックします。
現在3Dワールドに配置されているロボットは、[RV-7FRLL]です。
別のロボットを配置するので、[Mitsubishi Electric]をクリックし、[RV-7FRLL-SH]を3Dワールドにドラッグします。
[RV-7FRLL]と、[RV-7FRLL-SH]を交換します。
新しく配置したロボットを選択し、[プログラム]タブをクリックします。
[ツール]グループの中のコマンド[ロボット入れ替え]をクリックします。
3Dワールドでは、現在選択されているロボットと、入れ替え可能なロボットは、黄色でハイライトされます。
交換したいロボットを選択すると、緑色でハイライトされます。
選択できましたら、画面右側の[ロボット入れ替え]ウィンドウを確認し、[適用]ボタンをクリックします。
[RV-7FRLL-SH]を選択すると、[RV-7FRLL]に設定されていたサブルーチンが、[RV-7FRLL-SH]のプログラムエディタに表示されています。
[RV-7FRLL]を選択すると、そのプログラムエディタに、サブルーチンはありません。
[RV-7FRLL-SH]のプログラムが、動作するかテストします。
シミュレーションを実行します。
コンポーネントが生成され、センサー位置に到達すると、ロボットがピックアップします。
ピックアップされたコンポーネントを、隣のコンベアに置きます。
シミュレーションをリセットします。
次に、他のメーカーの異なるタイプのロボットと交換したい場合の交換方法を説明します。
[ホーム]タブをクリックし、eカタログから別のロボットを配置します。
[Robots]の中の[ABB]をクリックし、[IRB1400]を、3Dワールドにドラッグ＆ドロップします。
違うタイプの[IRB1400]と[RV-7FRLL-SH]を交換するために、[IRB1400]を選択します。
[プログラム]タブに戻り、コマンド[ロボット入れ替え]をクリックすると、[IRB1400]を、[RV-7FRLL-SH]または、[RV-7FRLL]と交換することができます。
コンポーネントをコンベアからピックアップするプログラムを、[IRB1400]を使用し、シミュレーションを実行するために、[RV-7FRLL-SH]を選択し、右下の[適用]ボタンをクリックすると、ロボットを入れ替えることができます。
シミュレーションを実行します。
コンポーネントが生成され、センサー位置に到達すると、ロボットがピックアップします。
ピックアップされたコンポーネントを、隣のコンベアに置かれます。
コンポーネントを置いたとき、コンベアとロボットが干渉した可能性があります。
干渉を確認するために、シミュレーションをリセットし、3Dワールドの干渉検出をオンにします。
[IRB1400]を選択します。
[干渉検出]グループの[ディテクターを編集]をクリックすると、画面右側に[干渉ディテクター]ウィンドウが表示されます。
選択したワールドが、選択されていることを確認します。
[干渉を検出]で[全て]を選択し、検出したすべての干渉を記録できるようにし、干渉間の最短距離をここでは表示しないので、[最短距離を表示]にチェックはつけません。
[ディテクターを編集]の下にある、[ディテクターを有効にする]と[干渉の停止]にチェックをつけます。
衝突したら停止することを確認するため、シミュレーションを実行します。
コンポーネントをピックアップし、隣のコンベアに搬送すると、ロボットとコンベアが衝突したので、シミュレーションを一時停止します。
交換したロボットプログラムは正常に動作しています。
ロボットの形状が、交換したロボットとは少し異なるので、衝突しシミュレーションが停止しました。
ロボットを移動させることでロボットが衝突しないようにできますが、プログラムで設定したロボットのP点の位置を、移動させたくありませんので、別の方法で修正します。
シミュレーションをリセットします。
次に、コマンド[選択]をクリックし、3Dワールドで、ロボットをコンポーネントとして選択します。
ロボットのP点の位置を、移動させたくありませんので、[位置固定]グループの中の[ワールドに対して]をクリックします。
[ワールドに対して]は、3DワールドでロボットのP点の位置を固定しているので、ロボットを移動させてもP点は移動しません。
コマンド[移動]を選択し、ロボットを衝突しない位置に移動させます。
ロボットのP点が、ロボットと共に移動していないことが確認できました。
シミュレーションを実行します。
ロボットがコンポーネントをピックアップします。
ロボットが、コンポーネントをピックアップするとき、衝突することがあります。
しかし、シミュレーションを停止させることなく、実行し続けています。
隣のコンベアにコンポーネントを搬送するとき、ロボットはコンベアと衝突しません。
もう一度、コンポーネントを置くとき、コンベアと衝突しました。
この問題を解決する方法は別の動画で説明しています。
シミュレーションをリセットします。
3Dワールドでロボットを交換する方法についての説明は以上となります。

=================================================================================

移動している製品の上に製品を乗せよう(1/2)

Pythonスクリプトを使用して、コンベア上に流れているワークをロボットでピックアップする方法についての説明
（関連動画：ロボットプログラムをPythonで記述してみよう、ロボットをPythonで制御して製品を整列してみよう）
https://youtu.be/vKi_gUE2A6s
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_159_p1.zip

移動している製品の上に製品を乗せる方法を説明します。
Pythonスクリプトを使用して、コンベア上に流れているワークをロボットでピックアップし、次に流れてくるワークの上に配置します。
パート1では、コンベア上に流れているワークをピックアップする方法を説明します。
関連動画として、「ロボットプログラムをPythonで記述してみよう」、「ロボットをPythonで制御して製品を整列してみよう」があります。是非ご覧ください。
3Dワールドにフィーダー、コンベア、ロボットを配置します。
eカタログの[タイプ別モデル]-[Feeders]を選択します。
[Basic Feeder]を配置します。
フィーダーにコンベアを接続します。
eカタログの[タイプ別モデル]-[Conveyor]-[Visual Components]を展開します。
フィーダーが選択された状態で、[Conveyor]をダブルクリックすると、フィーダーにコンベアが接続されます。
シミュレーションを実行すると、コンベアにワークが流れます。
シミュレーションを一時停止します。
パーツを選択すると、[コンポーネントプロパティ]ウィンドウでワークのサイズを確認できます。
ワークの高さは100mmということがわかります。
シミュレーションをリセットします。
ロボットを配置します。
eカタログの[タイプ別モデル]-[Robots]-[Mitsubishi Electric]を展開します。
[RV-13FL]を配置します。
ビューセレクタの[T]をクリックし、上面を表示します。
ロボットをコンベアに届く範囲へ移動します。
パイソンスクリプトを使用して、ロボットの動きを制御します。
コンベアを選択します。
[モデリング]タブを開きます。
[動作設定]-[ビヘイビア]-[その他]-[パイソンスクリプト]を追加します。
今回は使用しないため、OnSignal関数は削除します。
OnRun関数は今は不要なため、一旦削除します。
from vcHelpers.Robot2 import *と記述し、ロボットのライブラリを呼び出します。
ロボットのライブラリには、ロボットを制御するときに便利なメソッドが含まれています。
app = getApplication()と記述し、アプリケーション情報を取得します。
comp = getComponent()と記述し、Pythonスクリプトを設定しているコンポーネントを取得します。
path = comp.findBehaviour()と記述し、コンベアのビヘイビアを取得します。
ワークはコンベアのパスを通るため、パスの情報を取得します。
[コンポーネントグラフ]ウィンドウを確認すると、[Path]が表示されています。
ワークはPathを通るため、Pathと記述します。
robot = getRobot()と記述し、ロボットの情報を取得します。
パイソンスクリプトはロボット内になく、ロボットとコンベアはインタフェース接続されていないため、直接ロボット名を記述してロボットを指定できません。
そのため、app.findComponent()と記述し、コンポーネントの情報を取得します。
今回は、RV-13FLのロボットを使用しているため、RV-13FLと記述します。
print robotと記述し、ロボットの情報を[出力]ウィンドウに表示します。
コンパイルボタンをクリックします。
[出力]ウィンドウを確認すると、ロボットの情報が表示されています。
ロボットの情報を取得したことが確認できたため、print関数を削除します。
def OnRun()と記述し、シミュレーション実行中の動作を設定します。
while app.Simulation.IsRunning:と記述し、シミュレーション実行中にループ処理します。
if path.ComponentCount > 0:と記述し、パス上にコンポーネントが1つ以上あるときを条件にします。
print path.Componentsと記述し、パス上のコンポーネントの情報を[出力]ウィンドウに表示します。
ShiftとTabキーを押しながら、インデントを1つ減らします。
delay(2.0)と記述し、処理を2秒遅らせます。
コンパイルボタンをクリックします。
シミュレーションを実行します。
コンベア上にワークがあるとき、2秒ごとにワークの情報が取得されていることがわかります。
シミュレーションをリセットします。
ワークの情報を取得したことが確認できたため、print関数を削除します。
コンベアに入ってきた最初のワークをピックアップします。
part = path.Components[0]と記述し、パスに入ってきた最初のワークを取得します。
robot.pickMovingPart(part)と記述し、最初のワークをピックアップします。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ロボットが最初のワークをピックアップします。
次のワークが流れると、最初のワークを掴んだまま、次のワークを掴みます。
シミュレーションをリセットします。
最初のワークを掴んだまま、次のワークを掴まないようにします。
パイソンスクリプトを開きます。
if文の下にソースコードを追記します。
if robot.GraspContainer.ComponentCount == 0:と記述し、ロボットがワークを1つも掴んでいないときを条件に追加します。
下の2行を選択し、Tabキーを押し、インデントを1つ増やします。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ロボットが最初のワークをピックアップします。
次のワークが流れても、最初のワークを掴んだまま、待機します。
シミュレーションをリセットします。
パート1の説明は以上となりますが、ファイルを保存する場合は、getRobotをOnRun関数に入れてください。
OnRun関数に入れずにファイルを保存して再度開くと、コードが実行されますが、vcHelpers.Robot2を即座に読み取ることができずエラーが発生します。
そのため、OnRun関数に入れて、ファイルを読み込む際にコードをすぐに実行しないことで、エラーを回避できます。
コンベア上に流れているワークをピックアップする方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

移動している製品の上に製品を乗せよう(2/2)

Pythonスクリプトを使用して、コンベア上に流れているワークをロボットでピックアップし、次に流れるワークの上に積み上げる方法についての説明
（関連動画：ロボットプログラムをPythonで記述してみよう、ロボットをPythonで制御して製品を整列してみよう）
https://youtu.be/kWpeVJ0w90s
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_159_p2.zip

移動している製品の上に製品を乗せる方法を説明します。
パート1では、Pythonスクリプトを使用して、コンベア上に流れているワークをピックアップする方法を説明しました。
パート2では、Pythonスクリプトを使用して、コンベア上に流れているワークをピックアップし、積み上げます。
関連動画として、「ロボットプログラムをPythonで記述してみよう」、「ロボットをPythonで制御して製品を整列してみよう」があります。是非ご覧ください。
パート1で使用したファイル、もしくは、[Place Parts On Moving Objects_Part1_after.vcmx]をダウンロードし、開きます。
ロボットでピックアップしたワークを次のワークに乗せるため、位置を調整します。
コンベアを選択します。
[モデリング]タブを開きます。
パイソンスクリプトを開きます。
else:と記述し、ロボットがワークを掴んでいる状態を条件にします。
robot.linearMoveToMtx_ExternalBase()と記述します。
linearMoveToMtx_ExternalBaseは、指定したコンポーネントに向かって、ロボットを直線運動します。
流れているワークに向かって、RV-13FLのロボットを直線運動するため、robotを先頭に記述します。
ヘルプでメソッドの詳細を確認します。
[ヘルプ]タブを開き、[パイソンAPI]を選択します。
vcHelpers.Robot2を開きます。
スクロールすると、[メソッド]の項目にlinearMoveToMtx_ExternalBaseがあります。
Parametersを確認すると、引数で、移動先のコンポーネントと、マトリックスを使用してロボットの姿勢を指定できることがわかります。
マトリックスとは、行や列のことです。
ヘルプ画面を閉じます。
次に流れてくるワークに乗せるため、第一引数で次のワークをターゲットにします。
partをコピーし、elseの下に貼り付けます。
名前をpartからpalletに変更します。
if文のpartで最初のワークを既にピックアップしているため、elseでは、次に流れるワークがコンベアのPath上の0番目のワークになります。
linearMoveToMtxの第一引数にpalletと記述します。
第二引数にロボットの姿勢をマトリックスで指定します。
マトリックスを使用するため、import vcMatrixと記述します。
mtx = vcMatrix.new()と記述し、新しいマトリックスを作成します。
mtx.translateRel()と記述し、ワークの位置を基準にして、指定した位置まで移動します。
X軸とY軸は移動する必要がないため、0にします。
Z軸は、ワークの高さ分、+Z軸方向に移動する必要があります。
ワークの高さは100mmですが、ワークを積み上げると2個分の高さが必要なため、200にします。
linearMoveToMtxの第二引数にmtxと記述します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ロボットが最初のワークをピックアップします。
次のワークの上にロボットが移動しますが、ロボットの先端が反対を向いていることがわかります。
シミュレーションをリセットします。
ロボットの先端が-Z軸方向を向くように設定します。
mtx.rotateRelY(180)と記述し、Y軸を基準に180度回転します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ロボットが最初のワークをピックアップします。
次のワークの上にロボットが正しい向きで移動します。
シミュレーションをリセットします。
ピックアップしたワークを次のワークの上に配置します。
robot.releaseComponent(pllet)と記述し、次のワークの上に配置します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ロボットが最初のワークをピックアップします。
次のワークの上にロボットがワークを配置します。
同様に、次のワークへと積み上げていきます。
シミュレーションを一時停止します。
ワークを2個ずつ繰り返し積み上げるように設定します。
ワークが2個積まれている場合、上のワークは下のワークの子コンポーネントになります。
子コンポーネントを1つも持っていないとき、つまり、ワークが積まれていないとき、次のワークに配置します。
シミュレーションをリセットします。
if len(part.ChildComponents) == 0:と記述し、子コンポーネントの数が0のときを条件にします。
if文の下のソースコードにインデントを1つ増やします。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ロボットがワークを2個ずつ積み上げます。
遅延を2秒にしているため、ワークをピックアップするタイミングが少し遅いことがわかります。
シミュレーションをリセットします。
遅延の秒数を短くします。
delayを0.1秒にします。
コンパイルボタンをクリックします。
シミュレーションを実行します。
ロボットがワークを2個ずつ積み上げます。
2個積み上がったワークがコンベアからなくなった後、すぐにロボットが次のワークをピックアップしていることがわかります。
シミュレーションをリセットします。
リミットで停止が選択されている場合、シミュレーションの途中で動きが止まります。
[プログラム]タブを開きます。
[リミット]-[リミットで停止]にチェックが入った状態で、シミュレーションを実行すると、途中で動きが止まります。
ロボットを選択し、[ジョグ]ウィンドウを確認すると、J6が制限を超えたため、動きが止まっていることがわかります。
シミュレーションをリセットします。
J6にエラーが発生しないようにします。
ソースコードの19行目～22行目をコピーします。
pickMovingPartの上に貼り付け、ロボットでワークをピックアップするときも、ロボットの姿勢を指定することで、J6が制限を超えないようにします。
19行目の第一引数をpartに変更します。
コンパイルボタンをクリックします。
シミュレーションを実行します。
エラーで止まることなく、ロボットがワークを2個ずつ積み上げます。
[ジョグ]ウィンドウのJ6を確認すると、可動域内でJ6が動いていることがわかります。
コンベア上に流れているワークをピックアップし、積み上げる方法の説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

複数のロボットやPLCと連携しよう

RT ToolBox3で複数のロボット、GX Works3で複数のPLCと連携する方法
（関連動画：RT ToolBox3と連携しよう、コンベアを作ってシーケンサと繋いでみよう）
https://youtu.be/on8FKqFvoQ0
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_152.zip

Geminiと、複数のロボットやPLCを連携させる方法について説明します。
本動画では、RT ToolBox3とGX Works3を使用します。
最初は、Geminiと複数のRT ToolBox3を連携させる方法です。
付属ファイル「ConnectRT_before.vcmx」を開きます。
ロボットが8台配置されています。
1台のロボットを、1つのロボットプログラムで制御します。
ロボットを1台選択し、[プログラム]タブを開きます。
RT ToolBox3のロボットプログラムから指示を受けるため、Geminiのロボットプログラムは未設定です。
RT ToolBox3を起動します。
RT ToolBox3と連携する方法の詳細は、動画「RT ToolBox3と連携しよう」を参照してください。
付属ファイル「RT ToolBox3 RV-7F」内の、ワークスペースを開きます。
[シミュレーター]モードで、実行するプロジェクトを選択します。
RT ToolBox3で実行できるプロジェクトは、最大8つです。
9つ目のプロジェクトを実行すると、エラーが発生します。
8台のロボットと、8つの操作盤が表示されます。
全ての操作盤で、[開始]を選択します。
Geminiの画面を表示します。
RT ToolBox3と接続します。
[接続性]タブを開きます。
RTToolBox3との接続設定を追加します。
[MITSUBISHI ELECTRIC FA]を選択し、右クリックして、[サーバーを接続]を選択することで、接続設定を追加できます。
サーバーの名前を[RT1]に変更します。
[接続を編集]ウィンドウでは、接続の詳細を設定できます。
[PC側I/F]は、Geminiとの接続先です。
RTToolBox3を選択します。
RT ToolBox3側のロボットと、Gemini側のロボットの番号を一致させます。
[サーバー側ロボット]は、[1:RV-7FRL-Q]、[シミュレーション側ロボット]は、[RV-7FRL]です。
[接続をテスト]をクリックし、接続を確認します。
[適用]をクリックします。
[接続性コンフィグ]ウィンドウで、[RT1]の右側のアイコンをクリックし、接続します。
同様に、[サーバー]を7つ追加し、名前を[RT2]から[RT8]に変更します。
RT ToolBox3側とGemini側で、使用するロボットの番号を一致させます。
[RT2]から[RT8]と、RT ToolBox3を接続します。
Geminiのシミュレーションを実行します。
動作しないロボットがある場合、[接続済変数]ウィンドウを確認します。
[ステータス]が緑の場合、接続完了です。
[ステータス]が赤、または白の場合、接続が完了していません。
一度、Geminiのシミュレーションをリセットし、再度、実行します。
全てのロボットが動作することがわかります。
シミュレーションをリセットします。
次は、Geminiと複数のGX Works3を連携させる方法です。
付属ファイル「ConnectWorks3.vcmx」を開きます。
レール上を移動するブロックが4つ配置されています。
1つのブロックを、1つのGX Works3で制御します。
GX Works3と連携する方法の詳細は、動画「コンベアを作ってシーケンサと繋いでみよう」を参照してください。
付属ファイル「Works(1).gx3」、「Works(2).gx3」、「Works(3).gx3」、「「Works(4).gx3」」を起動します。
GX Works3のシミュレーションを開始します。
Geminiの画面を表示します。
GX Works3と接続します。
[接続性]タブを開きます。
[MITSUBISHI ELECTRIC FA]を選択し、右クリック、[サーバーを接続]を選択します。
サーバーの名前を[GX1]に変更します。
[接続を編集]ウィンドウの[PC側I/F]が、GX Simulator3であることを確認します。
[通信設定]をGX Works3と一致させます。
[GX Simulator3]ウィンドウを表示します。
[CPUシリーズ]は、RCPU、[CPUタイプ]は、[R16]です。
[システム番号]と[号機番号]は、1です。
[システム番号]と[号機番号]で、特定のGX Works3を指定できます。
最初に、シミュレーションを開始したGX Works3から、番号は付与されます。
GX Works3とは、最大4つ接続できます。
[システム番号]には、5と入力することができません。
[先頭デバイス・点数設定]で、X1から2点、Y1から2点、M1から1点、確保します。
[接続をテスト]をクリックし、接続を確認します。
[適用]をクリックします。
[接続性コンフィグ]ウィンドウで、[GX1]の右側のアイコンをクリックし、接続します。
同様に、[サーバー]を3つ追加し、名前を[GX2]から[GX4]に変更します。
[システム番号]は、2から4、[号機番号]は、すべて1です。
[先頭デバイス・点数設定]は、[GX1]と同様です。
[GX2]から[GX4]と、GX Works3を接続します。
Geminiと、GX Works3の変数ペアを作成します。
[シミュレーションからサーバーへ]では、X1、X2のペアを作成します。
ボタンをクリックすることで、ブロックの移動を開始させるため、[HMI Button]の[IsPressed]と[M1]のペアを作成します。
[サーバーからシミュレーションへ]では、Y1、Y2のペアを作成します。
[GX2]から[GX4]も、同様の変数ペアを作成します。
Geminiのシミュレーションを実行します。
ボタンをクリックすることで、ブロックの動作を開始できます。
[ホーム]タブを開きます。
[マニピュレーション]グループの[インタラクティブ]を選択し、ボタンをクリックします。
全てのブロックがレール上を往復します。
[接続済変数]ウィンドウで、GeminiとGX Works3の通信速度を確認できます。
シミュレーションをリセットします。
Geminiと、複数のロボットやPLCを連携させる方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================

三菱電機のロボットプログラムを出力しよう

三菱電機のロボットの動きをGeminiでティーチングして、MELFA-BASIC形式に変換出力し、RT ToolBox3で実行する方法
https://youtu.be/i40wtmeabrQ
https://www.mitsubishielectric.co.jp/fa/products/software/simulation-tools/gemini/sample/academy_131.zip

Geminiのロボットプログラムを、三菱電機のロボットMELFAシリーズのプログラムに出力する方法について説明します。
Geminiには、ロボットプログラムを、三菱電機のロボットプログラムであるMELFA-BASIC形式で出力する機能があります。
出力したロボットプログラムを、RT ToolBox3で取り込むことにより、再度、RT ToolBox3でロボットプログラムを作成する必要がなくなります。
ただし、MELFA-BASIC形式でロボットプログラムを出力できるロボットは、MELFAシリーズのみです。
3Dワールドに、MELFAシリーズのロボットを配置し、ロボットプログラムを作成します。
eカタログの[製造者別モデル]を展開し、[Mitsubishi Electric]を選択します。
[RV-7FRL]をダブルクリック、またはドラッグ＆ドロップすることで、3Dワールドに配置できます。
ダブルクリックの場合、ロボットは3Dワールドの原点に配置されます。
ドラッグ＆ドロップの場合、ロボットはドロップした位置に配置されます。
ロボットに、ティーチングすることで、動作を記録します。
[プログラム]タブを開きます。
[マニピュレーション]グループの[ジョグ]を選択することで、ロボットの可動部を動かすことができます。
ロボットの先端には、ティーチングの座標を決める際の基準点が、ピンク色の丸で表示されています。
基準点の位置に表示される矢印、面、弧、または、基準点自身であるピンク色の丸をドラッグすることで、ロボットを動かすことができます。
[ジョグ]ウィンドウの[ジョイント]で、ロボットの可動部の状況を確認できます。
可動部が制限値を超えると、[J1]から[J6]が赤く表示されます。
制限値を超えた動作をしない設定にする場合、[リミット]グループの[リミットで停止]にチェックを付けます。
3Dワールドで、赤い矢印をドラッグします。
制限値を超えずにロボットを動かすことができます。
シミュレーションのリセットボタンをクリックすることで、ロボットの可動部が初期状態に戻ります。
ロボットの先端が届く範囲を確認します。
ロボットを選択し、画面右下にある[コンポーネントプロパティ]をクリックします。
[コンポーネントプロパティ]ウィンドウの[WorkSpace]タブをクリックします。
[Profile]にチェックを付けることで、[J1]を含まない場合の、ロボットの先端が届く範囲を可視化できます。
ロボットの[J1]を回転させると、[Profile]で表示される範囲も回転します。
[Envelope]にチェックを付けることで、[J1]を含む場合の、ロボットの先端が届く範囲を可視化できます。
範囲内にも、ロボットの先端が届かない部分があるため、注意が必要です。
[Profile]と[Envelope]からチェックを外します。
リセットボタンをクリックします。
ロボットに、動作の目標位置を記録します。
シミュレーションを開始することで、[プログラムエディタ]ウィンドウの[Main]ルーチンに設定されたプログラムを実行できます。
初期位置を記録するため、[プログラムエディタ]ウィンドウの[各軸補間ステートメント]をクリックします。
各軸補間ステートメントで、目標位置を記録します。
各軸補間ステートメントは、可動部の現在値を補間することで、目標位置まで移動できます。
[Main]ルーチンに、P1が追加されたことがわかります。
3Dワールドに、P1が表示されない場合、3Dワールドツールバーの[フレームタイプ]を展開し、[ロボットポジション]にチェックを付けます。
矢印をドラッグ、または座標を入力することで、初期位置から、Z軸方向に-400mm、Y軸方向に+300mm移動させます。
座標を入力する場合、画面右下で[ジョグ]をクリックし、[ジョグ]ウィンドウを表示して、座標を変更する必要があります。
[プログラムエディタ]ウィンドウの[各軸補間ステートメント]をクリックします。
[Main]ルーチンに、P2が追加されたことがわかります。
[ジョグ]ウィンドウを表示し、Y軸方向に-600mm移動させます。
[プログラムエディタ]ウィンドウの[直線補間ステートメント]をクリックします。
直線補間ステートメントは、各軸補間ステートメントとは異なり、目標位置までの最短距離を移動できます。
[Main]ルーチンに、P3が追加されたことがわかります。
P2へ移動後、指定した秒数ロボットを待機させます。
[プログラムエディタ]ウィンドウの[遅延ステートメント]をクリックします。
遅延ステートメントは、次のプログラムの実行を、指定した秒数、遅延させることができます。
[ステートメントプロパティ]ウィンドウの[遅延]で、遅延させる秒数を定義できます。
[遅延]に3と入力します。
[プログラムエディタ]ウィンドウのDelay 3sを、P2とP3の間にドラッグ＆ドロップします。
可動部が制限値を超えた時、[出力]ウィンドウに、エラーメッセージを表示できます。
[リミット]グループの[メッセージパネル出力]にチェックを付けます。
リセットボタンをクリックします。
動作を確認するため、シミュレーションを実行します。
ロボットは、P1、P2、P3の順に移動し、P2からP3へ移動する前に3秒待機することがわかります。
P2からP3へ移動する時、可動部が制限値を超えたため、停止します。
[出力]ウィンドウに、ロボットの可動部が制限値を超えたことを表示しています。
シミュレーションをリセットします。
ロボットが、制限値を超えることで、停止しないようにするため、[プログラムエディタ]ウィンドウで、P3を削除します。
作成したロボットプログラムを出力します。
[変換出力]グループの[MELFA-BASIC形式]をクリックすることで、MELFAシリーズのロボットに設定されたプログラムを出力できます。
同じ名前のMELFA-BASICプログラムへの上書きの確認メッセージが表示されるため、[OK]をクリックします。
RT ToolBox3でロボットプログラムを取り込むため、RT ToolBox3のワークスペースにロボットプログラムを保存します。
[MELFA-BASIC形式へ変換出力]ウィンドウで、付属ファイル[RT ToolBox3]-[ワークスペース]-[RC1]-[Program]を選択します。
名前を[1]に変更し、[保存]をクリックします。
出力完了したプログラムが表示されます。
出力完了のメッセージが表示されるため、[OK]をクリックします。
[出力]ウィンドウには、プログラムの出力機能に非対応のステートメント、またはステートメントプロパティをスキップしたことが表示されています。
変換仕様は、ヘルプファイルで確認できます。
[ヘルプ]タブを開き、[ヘルプ]をクリックします。
[目次]の[ロボットプログラミング]を展開します。
[その他の操作]を展開し、[ロボットプログラムのエクスポート]を選択します。
[変換仕様]で、出力機能に非対応のステートメントを確認できます。
出力機能に対応しているステートメントの中には、非対応のステートメントプロパティを持つものもあります。
プログラムを出力する場合、注意事項があります。
プログラムは、MELFA-BASIC VI形式で出力されるため、異なるバージョンで使用する場合、バージョンに合わせてプログラムを修正する必要があります。
プログラム名、変数名は、MELFA-BASICの命名規則に従って設定します。
GeminiとRTToolBox3で、ロボットの原点が異なる場合、ロボットの姿勢が変化するため、修正する必要があります。
ロボットの先端にツールを接続した状態などで、動作を設定した場合、出力した目標位置は変化します。
ツールを接続していない状態で、プログラムを出力する必要があります。
RT ToolBox3と連携し、Gemini上のロボットを動作させます。
Gemini上のロボットは、RT ToolBox3に設定されたプログラムに従うため、[プログラム]タブを開き、[Main]ルーチンのプログラムをすべて削除します。
GeminiとRT ToolBox3の連携方法は、動画「RT ToolBox3と連携しよう」を参照してください。
RT ToolBox3で実行するプログラムを選択するため、[1:RC1 シミュレーション]ウィンドウの[リセット]をクリックします。
[プログラム]の[選択]で、[1]を選択し、[OK]をクリックします。
[サーボ入]と[開始]をクリックし、RT ToolBox3でプログラムを実行します。
Geminiのシミュレーションを開始します。
RT ToolBox3のプログラムに従って、Gemini上のロボットが動作しています。
Geminiのロボットプログラムを、三菱電機のロボットMELFAシリーズのプログラムに出力する方法についての説明は以上となります。
ご視聴いただき、ありがとうございました。

=================================================================================


